STM32F1 printf auf non blocking konfigurieren?

[Vincent (Gast)]

Hallo,

ich programmiere einen STM32F1 µController. Fürs printf benutze ich das 
https://github.com/cjlano/tinyprintf Bibliothek .

Ich habe den tinyprintf folgendermaßen konfiguriert.

init_printf(NULL, myputc);

void myputc(void* p, char c) {
  UNUSED(p);
  while ((USART3->SR & USART_FLAG_TC) == (uint16_t) RESET) {
  }
  USART_SendData(USART3, c);
}

Es funktioniert zwar wunderbar. Aber, wenn eine zeitkritische Aufgabe in 
ISR mit hohem Takt ca. 10kHz erledigt werden soll, wobei zeitgleich 
printf in der Mainschleife aufgerufen wird, wird diese ISR Funktion 
durch printf gestört. Ab und zu blockiert der printf die ISR Funktionen.

Weiß jemand zufällig wie man das lösen kann.

Viele Grüße aus Emmen.

[Rufus Τ. F. (rufus)]

Vincent schrieb:
> wird diese ISR Funktion durch printf gestört.

Was soll da der Wirkmechanismus sein?

Wird in der ISR auch auf UART3 zugegriffen?

[Vincent (Gast)]

Rufus Τ. F. schrieb:
> Vincent schrieb:
>> wird diese ISR Funktion durch printf gestört.
>
> Was soll da der Wirkmechanismus sein?
>
> Wird in der ISR auch auf UART3 zugegriffen?

Ne, In der ISR werden Hallsensor-Zustände eines BLDC Motors und 
Strommessung sowie einen Drehzahl-Regelkreis betrieben. Wenn der printf 
in der Mainschleife aufgerufen wird, wird der Regelkreis-Taktzyklus 
unterbrochen.

[Rufus Τ. F. (rufus)]

Dann stimmt da irgendwas grundlegendes nicht.

Was macht die Funktion UART_SendData?

[Vincent (Gast)]

Rufus Τ. F. schrieb:
> Dann stimmt da irgendwas grundlegendes nicht.
>
> Was macht die Funktion UART_SendData?

der macht:

/**
  * @brief  Transmits single data through the USARTx peripheral.
  * @param  USARTx: Select the USART or the UART peripheral. 
  *   This parameter can be one of the following values:
  *   USART1, USART2, USART3, UART4 or UART5.
  * @param  Data: the data to transmit.
  * @retval None
  */
void USART_SendData(USART_TypeDef* USARTx, uint16_t Data)
{
  /* Check the parameters */
  assert_param(IS_USART_ALL_PERIPH(USARTx));
  assert_param(IS_USART_DATA(Data)); 
    
  /* Transmit Data */
  USARTx->DR = (Data & (uint16_t)0x01FF);
}

[Nop (Gast)]

Also so, wie das hier gemacht ist, blockiert das printf keine 
Interrupts. Man müßte sich jetzt aber auch nochmal die Initialisierung 
des USART angucken, nicht daß da noch irgendwo irrtümlich ein Interrupt 
z.B. für "TX done" eingerichtet wurde. Oder für den RX-Zweig ein 
Interrupt. Also, gehen würde es dann immer noch, aber man müßte die 
Interruptprios dann schon richtig setzen.

Kannst ja mal spaßeshalber den Aufruf der send-usart-Routine 
auskommentieren und gucken, ob es dann geht.

Und was findet denn außer printf noch so in der Mainschleife statt?

[Vincent (Gast)]

Nop schrieb:
> Also so, wie das hier gemacht ist, blockiert das printf keine
> Interrupts. Man müßte sich jetzt aber auch nochmal die Initialisierung
> des USART angucken, nicht daß da noch irgendwo irrtümlich ein Interrupt
> z.B. für "TX done" eingerichtet wurde. Oder für den RX-Zweig ein
> Interrupt. Also, gehen würde es dann immer noch, aber man müßte die
> Interruptprios dann schon richtig setzen.
>
> Kannst ja mal spaßeshalber den Aufruf der send-usart-Routine
> auskommentieren und gucken, ob es dann geht.
auskommentiert, es läuft.

> Und was findet denn außer printf noch so in der Mainschleife statt?
Led togglen und noch Delay(100ms)

Ich hab die ISR Prioritäten alles auf 0 gesetzt, keine Verbesserung.
die UART NVIC Initialisierung:

void USART_Configuration(void) {
  USART_InitTypeDef USART_InitStructure;

  USART_InitStructure.USART_BaudRate = 115200;
  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;

  /* Configure USART3 */
  USART_Init(USART3, &USART_InitStructure);
  USART_Cmd(USART3, ENABLE);
}

void NVIC_Configuration(void) {
  NVIC_InitTypeDef NVIC_InitStructure;

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

  /* Configure and enable ADC interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = ADC1_2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
}

void EXTI15_10_IRQHandler(void) {
  if (EXTI_GetITStatus(EXTI_Line10) != RESET) {
    /* Clear interrupt flag */
    EXTI_ClearITPendingBit(EXTI_Line10);

    HallIRQ_L();
  }
  if (EXTI_GetITStatus(EXTI_Line11) != RESET) {
    /* Clear interrupt flag */
    EXTI_ClearITPendingBit(EXTI_Line11);

    HallIRQ_L();
  }
  if (EXTI_GetITStatus(EXTI_Line12) != RESET) {
    /* Clear interrupt flag */
    EXTI_ClearITPendingBit(EXTI_Line12);

    HallIRQ_L();
  }

}

void ADC1_2_IRQHandler(void) {
  GPIOA->ODR ^= GPIO_Pin_2;
  /* Clear ADC1 JEOC pending interrupt bit */
  ADC_ClearITPendingBit(ADC1, ADC_IT_JEOC);

  ControlLoop();

  GPIOA->ODR ^= GPIO_Pin_2;

}

[pegel (Gast)]

Vincent schrieb:
> wenn eine zeitkritische Aufgabe in
> ISR mit hohem Takt ca. 10kHz

Meinst du den ADC?
Setz doch dessen Priorität mal höher.

[Vincent (Gast)]

pegel schrieb:
> Vincent schrieb:
>> wenn eine zeitkritische Aufgabe in
>> ISR mit hohem Takt ca. 10kHz
>
> Meinst du den ADC?
Ja,
> Setz doch dessen Priorität mal höher.

ich habe die beiden (Preemption, Sub) Prioritäten auf 0x01. Keine 
Änderung.

[pegel (Gast)]

Hast du auch den Takt auf max. gesetzt?
Nicht das er es einfach nicht schafft.