Frage zu delay (mit SysTick) für den STM32f4

[jogl (Gast)]

Guten Tag,

ich habe eine delay Funktion mit dem SysTick von folgender Homepage.
http://patrickleyman.be/blog/stm32f407-delay-with-systick/

Damit habe ich folgendes Programm geschrieben:

uint32_t counter=0;

void init_LED(){
  //Anschalten der Taktversorgung für Port D
  RCC->AHB1ENR |= (1<<3);
  
  //Konfigurationsregister für den I/O-Port
  GPIOD->MODER |= (1<<24);
  GPIOD->MODER |= (1<<26);
}

void delay(int time){
  
  while(counter!=time){
  }
  
  counter=0;
}

void SysTick_Handler(void){
  counter++;
}

int main ()
{
  //Configure SysTick to generate an interrupt every millisecond 
  SysTick_Config(SystemCoreClock/1000);
  
  init_LED();

  do
  {
    GPIOD->BSRRL |= (1<<12);
    delay(6000);
    GPIOD->BSRRH |= (1<<12);
    delay(3000);
    
  }
  while (1);
}

Diese Funktion habe ich in zwei verschiedene Projekt eingebunden. In 
einem funktioniert sie und in der anderen ist die Wartezeit deutlich 
länger.

Das wird wohl an den Einstellungen für die SystemCoreClock liegen? Auf 
welchen Wert muss ich diese dann einstellen?

[Haas (Gast)]

Du musst die Variable SystemCoreClock einfach auf den Wert stellen den 
dein Mikrocontroller als Takt hat.

Durch die Funktion:

SysTick_Config(SystemCoreClock/1000);

wird dann sichergestellt, dass der Systick 1ms ist.

Wird jetzt für SystemCoreClock ein andere Wert eingesetzt ist Systick 
nicht mehr 1ms. Deshalb funktioniert das ganze unterschiedlich in deinen 
zwei Projekten.

[aSma>> (Gast)]

Servus,
deklariere den counter mit volatile davor.

mfg

[W.S. (Gast)]

jogl schrieb:
> Damit habe ich folgendes Programm geschrieben:

Und ich sage dir: Es ist Murks.

Warum?
Weil zwei voneinande unabhängige Instanzen schreibend auf die gleiche 
Variable zugreifen. Darum.

Abgesehen davon kann dein ganzer µC während der Wartezeiten rein garnix 
Vernünftiges anderes machen, sondern trampelt die ganze Zeit stupide auf 
der Stelle.

Mein Rat: Arbeite mit Events. Hättest du zuvor dir die mittlerweile 
steinalte Lernbetty heruntergeladen und dort geschaut, wie man eine 
Systemuhr programmiert und wie man Verzögerungen (delayed events) 
benutzt, dann hättest du gewiß ein besseres Programm geschrieben.

W.S.

[Jim M. (turboj)]

Ich sags nur ungern, aber sobald der Optimizer an ist wird aus dem 
delay() eine Endlosschleife. Die Variable ist nicth "volatile" 
deklariert.

W.S. schrieb:
> Weil zwei voneinande unabhängige Instanzen schreibend auf die gleiche
> Variable zugreifen. Darum.

In dem Falle Wurst. Das Schreiben in delay() ist atomar.

Sein größeres Problem ist die flasche Reihenfolge von "schreiben" und 
Warten im delay(). Deshalb hat er auch vom sonstigen Programmfluss 
abhängige Ergebnisse, da die Wartezeit vom letzten delay aus zählt. 
Spaß gibt es insbesondere wenn counter > time ist.

[jogl (Gast)]

Danke für eure Hinweise. So wie ich das nun auffasse ist es mit dem 
volatile vor der Variable nicht getan und einen anderen Ansatz habe ich 
gerade nicht.

Hätte jemand bitte eine "saubere" Lösungsvariante für mich?

[holger (Gast)]

Versuch das mal so:

volatile uint32_t counter=0;

void delay(uint_32t time){
  
  counter = time;

  while(counter){  }
}

void SysTick_Handler(void){
  if(counter) counter--;
}

[aSma>> (Gast)]

Ja, oder irgendwie sowas in der Art:

uint32_t counter_ms;

void SysTick_Handler(void){
  counter_ms++;
}

void delay_ms(uint32_t ntime_ms){
  uint32_t cur_time_ms = counter_ms;
  while(counter_ms-cur_time_ms < ntime_ms)
    ;
}

Achtung nach ca. 50 Tagen hat man einen Überlauf vom counter_ms.

[Jens (Gast)]

aSma>> schrieb:
> Achtung nach ca. 50 Tagen hat man einen Überlauf vom counter_ms.

History repeats itself:
http://www.cnet.com/news/windows-may-crash-after-49-7-days/

[W.S. (Gast)]

jogl schrieb:
> Hätte jemand bitte eine "saubere" Lösungsvariante für mich?

Kannst du lesen? Insbesondere meinen obigen Beitrag?

W.S.

[wikinger (Gast)]

holger schrieb:
> Versuch das mal so:

Ich habe in einem anderen Beitrag folgenden Code von dir gefunden:

/**
  ******************************************************************************
  * @file    main.c
  */ 

/* Includes ------------------------------------------------------------------*/
#include <stdint.h>

#include "misc.h"
#include "stm32f4xx.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_tim.h"

#include "leds.h"

void Delay1ms(uint32_t nCount);
volatile uint32_t delay1ms;

/**
  * @brief  Main program
  */
int main(void)
{
  // Discovery Board LEDs
  LEDs_Init();
  SysTick_Config(SystemCoreClock/1000);

  while (1)
  {
    LED_ORANGE_ON;
    Delay1ms(100);
    LED_ORANGE_OFF;
    Delay1ms(300);
  }
}

/**
  * @brief  This function handles SysTick Handler.
  * @param  None
  * @retval None
  */
void SysTick_Handler(void)
{
 if(delay1ms) delay1ms--;
}

/**
  * @brief  Delay Function.
  * @param  nCount:specifies the Delay time length.
  * @retval None
  */
void Delay1ms(uint32_t nCount)
{
  delay1ms = nCount;
  while(delay1ms);
}

Was ich hierbei noch nicht verstehe ist, was du mit dieser Funktion 
machst:
SysTick_Config(SystemCoreClock/1000);

Welchen Wert hat mein SystemCoreClock? Ich gehe mal davon aus, dass sind 
die 168MHz beim STM32F4. Wie kommt man dann aber darauf, dass er jede 
Millisekunde in den Systick_Handler geht?

[Haas (Gast)]

Der SysTickTimer funktioniert wie ein Upcounter (Hochzähler).

Er läuft bei den STM32 mit Systemtakt und zählt bis zu einem vom User 
vorgegebenen Wert. Dieser Wert kann unter anderem über die Funktion: 
SysTick_Config(SystemCoreClock/1000); eingestellt werden (oder z.B. 
direkt über Register).

Wenn ich die 168 MHz (SystemCoreClock) durch 1000 teile, bekomme ich 
168000 heraus. Es wird also bis zu diesem Wert gezählt und dann ein 
Interrupt ausgelöst. Um die 168000 Ereignisse mit einem Takt von 168 MHz 
zu zählen benötigt der Mikrocontroller:

168000 / 168 MHz = 1 ms

Gruß

[lolo (Gast)]

Jim M. schrieb:
> Ich sags nur ungern, aber sobald der Optimizer an ist wird aus dem
> delay() eine Endlosschleife. Die Variable ist nicth "volatile"
> deklariert.

Wieso muss man die Variable hier als volatile deklarieren?

Ich kenne die Definition von volatile: Solch eine Variable kann ihren 
Wert ständig ändern.

Aber kann dies auch nicht eine normale Variable? Und warum benötigt man 
dies hier überhaupt?

[W.S. (Gast)]

lolo schrieb:
> Wieso muss man die Variable hier als volatile deklarieren?

Dieses Attribut "volatile" weist den Compiler darauf hin, daß die damit 
bezeichnete Variable auch von einer anderen Instanz als der Funktion, 
die er grad am Übersetzen ist, verändert werden kann und er deshalb 
diese Variable für jede Verwendung neu laden muß und sie nicht 
wegoptimieren darf. Klaro?

Aber das Lesen bzw. Zuhören scheint den hier aufschlagenden 
Hilfesuchenden nicht in die Wiege gelegt zu sein. Begreift mal das 
Prinzip des Arbeitens mit Events und verzögerten Events. Man muß in main 
nicht wirklich auf dem SysTick direkt herumtrampeln, sowas macht man mit 
einer programminternen Uhr, die auf dem Systick beruht, selbigen aber so 
gut es geht kapselt und einem entsprechende Events generiert.

W.S.

[Lernbetty (Gast)]

>ie auf dem Systick beruht, selbigen aber so
>ut es geht kapselt und einem entsprechende Events generiert.

Halt so, wie bei der Lernbetty

[lolo (Gast)]

W.S. schrieb:
> Dieses Attribut "volatile" weist den Compiler darauf hin, daß die damit
> bezeichnete Variable auch von einer anderen Instanz als der Funktion,
> die er grad am Übersetzen ist, verändert werden kann und er deshalb
> diese Variable für jede Verwendung neu laden muß und sie nicht
> wegoptimieren darf. Klaro?

Und diese andere Instanz ist das Interrupt?