STM32F429 Anfängerfragen

[Michael Bauer (Gast)]

Hallo,

ich steige gerade in die Welt der Cortex-M4 ein und habe mir dazu das 
Discovery Kit mit dem STM32F429ZI geholt. Als IDE habe ich mir jetzt für 
den Anfang den Keil uVision5 geholt. Nun bin ich dabei mir ein paar 
Beispielprogramme anzuschauen. Nur hänge ich an folgendem Code für die 
Geschwindigkeit des Systick.

  SystemCoreClockUpdate();                      /* Get Core Clock Frequency   */
  if (SysTick_Config(SystemCoreClock / 1000)) { /* SysTick 1 msec interrupts  */
    while (1);                                  /* Capture error              */
  }

Get Core Clock ist mir klar und auch SysTick 1 msec habe ich mir 
angeschaut und verstanden, nur die while(1) ist mir unklar. Die Funktion 
SysTick_Config gibt bei Erfolg eine 0 und bei einem Fehler eine 1 
zurück. Wenn das Einstellen nun schief geht springt er in die 
Whileschleife aber wie kommt er da wieder raus ? Es kann doch nicht 
sein, dass bei einem Fehler der uC sich aufängt und einen Hardwarereset 
braucht ?

Gruß Michael

[m.n. (Gast)]

Michael Bauer schrieb:
> Wenn das Einstellen nun schief geht springt er in die
> Whileschleife aber wie kommt er da wieder raus ?

Er soll dort nicht herauskommen, sondern verfolgbar machen, wo der 
Fehler passiert ist. Man könnte auch im Debugger einen Breakpoint 
setzen.

[Sukzessive A. (sukapxconv)]

Er probiert an der Stelle solange den SysTick einzustellen bis es 
geklappt hat. Ist doch sofort ersichtlich ;)

[Augen weit offen (Gast)]

Sukzessive Approximation schrieb:
> Er probiert an der Stelle solange den SysTick einzustellen bis es
> geklappt hat. Ist doch sofort ersichtlich

Dann putz deine Brille und schaus dir noch einmal an. ;-)))

[Sukzessive A. (sukapxconv)]

  SystemCoreClockUpdate();                      /* Get Core Clock Frequency   */
  while (SysTick_Config(SystemCoreClock / 1000)) { /* SysTick 1 msec interrupts  */
    if (1);                                  /* Capture error              */
  }

Stand doch so da oder ?

davon troll :D

[Augen weit offen (Gast)]

Sukzessive Approximation schrieb:
> Er probiert an der Stelle solange den SysTick einzustellen bis es
> geklappt hat.

Nein, es probiert es nur ein einziges Mal. Schlägt das fehl, tritt er 
auf der Stelle. Oder was macht "while (1) ;" deiner Meinung nach?

Ich nix Troll, sondern wach. ;-)))

[Helmut L. (helmi1)]

Das sind nur Beispielprogramme, die muessen nicht vollstaendig sein oder 
etwas sinnvolles tun. An der Stelle des "while(1)" kann man eine eigene 
Fehlerbehndlungsroutine setzen.

[Michael Bauer (Gast)]

Ok, vielen dank für die Infos.
Hab mir jetzt ein kleines Programm gebastelt, dass einfasch nur einen 
Pin auf 1 setzen soll. Das Programm funktioniert nur wenn ich in 
uVision5 in dem Debug mode bin und dort auf Run klicke. Wenn ich nicht 
im Debugmode bin und das Programm auf den uC lade tut sich an dem Pin 
nichts...Ich weis es ist nicht leicht mit so wenig angaben eine guten 
Rat zu geben, aber vielleicht hatte jemand schonmal ein ähnliches 
Problem.

#include <stdio.h>
#include "STM32F4xx.h"
#include "GPIO_STM32F4xx.h"

volatile uint32_t msTicks;                      /* counts 1ms timeTicks       */

/*----------------------------------------------------------------------------
  SysTick_Handler
 *----------------------------------------------------------------------------*/
void SysTick_Handler(void) {
  msTicks++;
}

/*----------------------------------------------------------------------------
  delays number of tick Systicks (happens every 1 ms)
 *----------------------------------------------------------------------------*/
void Delay (uint32_t dlyTicks) {                                              
  uint32_t curTicks;

  curTicks = msTicks;
  while ((msTicks - curTicks) < dlyTicks);
}


/*----------------------------------------------------------------------------
  Main function
 *----------------------------------------------------------------------------*/
int main (void) {

  SystemCoreClockUpdate();                      /* Get Core Clock Frequency   */
  if (SysTick_Config(SystemCoreClock / 1000)) { /* SysTick 1 msec interrupts  */
    //while (1);                                  /* Capture error              */
  }
    GPIO_PortClock   (GPIOD, true);
    GPIO_PinWrite    (GPIOD, 12, 0);
    GPIO_PinConfigure(GPIOD, 12,
                      GPIO_MODE_OUTPUT,
                      GPIO_OUTPUT_PUSH_PULL,
                      GPIO_OUTPUT_SPEED_50MHz,
                      GPIO_PULL_DOWN);
  
  while(1) {
    GPIO_PinWrite(GPIOD, 12, 1);
    Delay(2000);
    GPIO_PinWrite(GPIOD, 12, 0);
    Delay(2000);
    GPIO_PinWrite(GPIOD, 12, 1);
    Delay(2000);
    GPIO_PinWrite(GPIOD, 12, 0);
    Delay(2000);
  }
}

[Lutz H. (luhe)]

Ich hatte  ein Beispielprogramm, da wurde nach Initialisierung des 
Systick wurde alle 1 ms eine Funktion (siehe BSP_Background() 
)aufgerufen.


/**
  * @brief  This function handles SysTick Handler.
  * @param  None
  * @retval None
  */
void SysTick_Handler(void)
{
 // OS_TimeMS ++;

  BSP_Background();

}

[Lutz H. (luhe)]

Michael Bauer schrieb:
> Die Funktion
> SysTick_Config gibt bei Erfolg eine 0 und bei einem Fehler eine 1
> zurück.

1 or 0 == true or false?

Meiner Meinung nach ist es eine Unsitte aus Lochkartenzeiten,
logische Werte beim Programmieren  mit 0 oder 1 zu bezeichnen.
Ich nutze nur noch true oder false, da kann der Compiler tun, was er 
will.



Ich denke mir das Programm soll, wenn der SysTick richtig konfiguriert 
ist,
in einer Endlosschleife laufen, die nichts macht, sonst soll das 
Programm sich beenden.


Durch einen Interrupt das SysTick wird  der   SysTick_Handler
aufgerufen. Dort kann die Funktion aufgerufen werden, die jede 1 ms 
ausgeführt werden soll.