STM32F0 Systick Main routine freezed

[Humpawumpa (Gast)]

Ich hab ein Problem das ich nicht so richtig verstehe.
Ich habe einen SysTick interrupt der alle 10ms aufgerufen wird und 
eigentlich ausser bei jedem 100sten Aufruf eine Message auszugeben 
weiter nichts machen muss.
In der main routine wird der aktuelle Wert des RTC ausgegeben.

Das funktioniert soweit auch wie erwartet, allerdings hört die main 
routine irgendwann auf und ich kriege nur noch die Outputs des SysTick. 
Habe ich irgendetwas grundlegendes übersehen?
Und ist es normal das

SysTick_Config(SystemCoreClock)

nicht funktioniert (Kriege dann keine Interrupts)?

/*
/ Description:
/ Date:
/ Filename: main.c
*/
/* Includes */  
#include <stdio.h>
#include <stdint.h>
#include <inc/stm32f0xx.h>
#include <inc/stm32f0xx_rtc.h>
#include <inc/stm32f0xx_rcc.h>
#include <inc/stm32f0xx_pwr.h>
#include <inc/stm32f0xx_gpio.h>

#include "inc/uart.h"
#include "inc/i2c.h"
#include "inc/clock.h"
#include "inc/utility.h"

/* Definitions */
#define BSRR_VAL      0x0300
#define WAIT_MS       500
#define SYSTICK_RATE   1000

/* Prototypes */
void GPIO_init(void);
void RTCInit(void);
void setLEDs(void);
void resetLEDs(void);

/* Declarations */
char buffer[16];
uint8_t IRQ_REG;
uint8_t btnRegister = 0;
GPIO_InitTypeDef        GPIO_InitStructure;
RTC_TimeTypeDef     RTC_ActualTimeTMP;
NVIC_InitTypeDef    NVIC_InitStructure;
EXTI_InitTypeDef      EXTI_InitStructure;

/* Temporary */
uint8_t x;
uint8_t systickDelay = 0;

/* The Mainroutine, initializes all peripherals and IOs */
int main(void)
{
  /**/
  SystemInit();
  
  /**/
  GPIO_init();
  printf("GPIO configured\n");

  /**/
  UartInit();
  printf("UART configured\n");
  
  /**/
  SystemCoreClockUpdate();
  SysTick_Config(SystemCoreClock/100);
  printf("SysteCoreClock is %d\n", SystemCoreClock);
  
  /**/
  I2CInit();
  printf("I2C configured\n");

  /**/
  RTC_Config();
  printf("RTC initialized\n");

  Clock_init();
  /**/

  //SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);
  
  /* Configure the external interrupt */
  EXTI_ClearITPendingBit(EXTI_Line19|EXTI_Line0|EXTI_Line1|EXTI_Line2|EXTI_Line3);
  EXTI_InitStructure.EXTI_Line = EXTI_Line19;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  EXTI_InitStructure.EXTI_Line = EXTI_Line0;
  EXTI_Init(&EXTI_InitStructure);
  EXTI_InitStructure.EXTI_Line = EXTI_Line1;
  EXTI_Init(&EXTI_InitStructure);
  EXTI_InitStructure.EXTI_Line = EXTI_Line2;
  EXTI_Init(&EXTI_InitStructure);
  EXTI_InitStructure.EXTI_Line = EXTI_Line3;
  EXTI_Init(&EXTI_InitStructure);
  
  NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  NVIC_InitStructure.NVIC_IRQChannel = EXTI0_1_IRQn;
  NVIC_Init(&NVIC_InitStructure);
//  SYSCFG_EXTILineConfig();
  I2C_SendSomething();
  
  // Test fading

  for(x = 0; x < 16; x++){
    setBrightness(16*x);
    wait_ms(100);
  }
  
  while (1){
    ClockStatemachine();
    printf("Maintask still running\n");
    wait_ms(1000);
   
    }
}

  
void GPIO_init(void) 
  {
  //GPIOC Periph clock enable
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
  
  //Configure PC8 and PC9 in output pushpull mode 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOC, &GPIO_InitStructure);
  }

void setLEDs(void)
  {
  GPIOC->BSRR = BSRR_VAL;
  }
  
void resetLEDs(void)
  {
  GPIOC->BRR = BSRR_VAL;
  }


void SysTick_Handler(void)
{
    //printf("systemTicker triggered\n");
    if(systickDelay == 100){
      systickDelay = 0;
      printf("systemTicker triggered\n");
    } else { systickDelay++;
    }
    //IRQ_REG &= 0x01;
}

void EXTI0_IRQHandler(void){
  if(EXTI_GetITStatus(EXTI_Line0) != RESET){
    printf("interrupt 0\n");
    EXTI_ClearITPendingBit(EXTI_Line0);
  }
    
}

[Humpawumpa (Gast)]

Vielleicht noch als Ergänzung, wenn ich den Systick nicht starte, dann 
läuft soweit ich das beurteilen kann alles.

[hp-freund (Gast)]

Humpawumpa schrieb:
> uint8_t systickDelay = 0;

Das Erste das mir auffällt: systickDelay wird im Interrupt verwendet, 
also fehlt ein ... ?

[Tassilo H. (tassilo_h)]

Ist printf re-entrant? D.h. ist es zulaessig, dass printf von einem 
Interrupt unterbrochen wird, in dem dann auch printf aufgerufen wird? 
Wahrscheinlich nicht (in vielen Implementierungen)!

Deklariere ein globales flag (volatile nicht vergessen), das Du im 
systick setzt, wenn printf aufgerufen werden soll, und mache den 
printf-aufruf in der Hauptschleife.

[Jim M. (turboj)]

Wenn printf() nicht reentrant ist, könnte das im Interrupt knallen. Dito 
wenn printf() selbst Interrupts verwendet.

Außerdem könnte die Ausgabe länger dauern als ein Interrupt.