STM32 Systicktimer wert in ms

[Marcel (Gast)]

Hallo,

ich würde gerne eine Variable mit dem aktuellen Systicktimer Wert 
versehen, welchen ich über die UART versenden mag.

Irgendwie so:

int Ticker =0;
Ticker = SysTick;


printf("Laufzeit: %i", Ticker);

Sinn und Zweck, ich moechte gerne ueber die UART die Laufzeit des uC 
versenden, zu einem Sensormesswert.

am ende schaut das so aus:

Sample, Sampletime, Messwert1, Messwert2  ..

Habt ihr eine Idee?

Gruss
Marcel

[holger (Gast)]

>Habt ihr eine Idee?

Beispiel aus der Standard Peripheral Lib ansehen?

[holger (Gast)]

Übrigends ein 32 Bit Zähler läuft bei 1ms Takt nach ca. 50 Tagen über.

[Marcel (Gast)]

Und was gibts da fuer moeglichkeiten, diesen vor einem ueberlauf zu 
schuetzen ?

davon abgesehen das dass geraet max. 2 std. lauft

[Verwirrter Anfänger (Gast)]

Marcel schrieb:
> Und was gibts da fuer moeglichkeiten, diesen vor einem ueberlauf zu
> schuetzen ?
Du könntest dir einen eigenen Zähler bauen, der zaehlt wie oft der 
Systick übergelaufen ist. Du musst dann nur innerhalb von 50 Tagen 
zweimal den Systick abrufen.

[holger (Gast)]

>> Und was gibts da fuer moeglichkeiten, diesen vor einem ueberlauf zu
>> schuetzen ?
>Du könntest dir einen eigenen Zähler bauen, der zaehlt wie oft der
>Systick übergelaufen ist. Du musst dann nur innerhalb von 50 Tagen
>zweimal den Systick abrufen.

Falsch. Der Systick selber hat nur 24Bit. Der wird benutzt
um einen 1ms Interrupt zu erzeugen. Dort zählst du eine
Variable im 1ms Takt hoch. Wenn 50 Tage zu wenig sind
zählt man halt wenn diese Variable 1000 erreicht hat eine
zweite Variable hoch und setzt die erste auf Null.

[Marcel (Gast)]

ich hab jetzt folgendes gemacht.

in main eine

volatile int32_t mtime=0;

erstellt und im stm32f10x_it.c im Systick_handler eine funktion erstellt 
die mein mtime hochzaehlt :

void SysTick_Handler(void)
{
  TimValAdd();  
}


void TimValAdd(){
  
  mtime++;
  
  }

Nur wann passiert der Interrupt denn immer? bzw ist mtime in ms oder us 
?

Ich hab folgendes konfiguriert:

  /* Configure HCLK clock as SysTick clock source. */
  SysTick_CLKSourceConfig( SysTick_CLKSource_HCLK );

  /* set SysTick */
  SystemCoreClockUpdate();
  
  SysTick_Config(SystemCoreClock / 100);     /* Generate interrupt each 10 ms */

und meine Delay funktion:

 void Delay_us(uint32_t time_us) //Delay in usec
{
  SysTick->LOAD  = 72 * time_us-1;
  /* Load the SysTick Counter Value */
  SysTick->VAL   = 0;          
  /* Enable SysTick Timer */  
  SysTick->CTRL  |= SysTick_CTRL_ENABLE_Msk;                   

  do
  {
  } while ((SysTick->CTRL & SysTick_CTRL_COUNTFLAG)==0);
  /* Disable SysTick Timer */
  SysTick->CTRL  &= ~SysTick_CTRL_ENABLE_Msk;                  
  /* Load the SysTick Counter Value */
  SysTick->VAL   = 0;                                          
}


void Delay(uint16_t time_ms) //Delay in msec
{
  while (time_ms>0)
  {
    Delay_us(1000);
    time_ms--;
  }
}

[Marcel (Gast)]

Alle 10msec oder?

Viele Gruesse!

[holger (Gast)]

>und meine Delay funktion:

Ersatzlos löschen. Was treibst du da?
Der Systick wird nicht angefasst. Der läuft einfach frei weiter.
Also Finger weg.

Dein Systick Interrupt kommt alle 10ms.

[Marcel (Gast)]

Ja wie soll denn sonst die Delay funktion gemacht werden oder was meinst 
du bitte schoen mit nicht anfassen?

Meinst du etwa, das ich in den handler geschrieben hab ?

[Marcel (Gast)]

ok ich hab das jetzt mal nach dem template example von der std. lib 
gemacht

void SysTick_Handler(void)
{
  TimValAdd();
  TimingDelay_Decrement();
  
}

und

in main

void Delay(__IO uint32_t nTime)
{ 
  TimingDelay = nTime;

  while(TimingDelay != 0);
}

/**
  * @brief  Decrements the TimingDelay variable.
  * @param  None
  * @retval None
  */
void TimingDelay_Decrement(void)
{
  if (TimingDelay != 0x00)
  { 
    TimingDelay--;
  }
}

dann hab ich ja Delay(wertinMs)

und meine Variable mtime die sich hochzaehlt alle 10msec

[holger (Gast)]

>Meinst du etwa, das ich in den handler geschrieben hab ?

Du bastelst am Systick rum. Dann kommt der Interrupt
nicht mehr alle 10ms weil du den Systick manipulierst.

Und wieso ist mtime int? Können Zeiten negativ werden?
volatile int32_t mtime=0;

Was willst du eigentlich machen?

[Marcel (Gast)]

ok, dann uint32_t sorry.

Aber im Example wurde doch auch eine Funktion in den Handler geschrieben 
(systick example fuer Delay funktionen)

Ich wollte urspruenglich einfach nur einen Wert in millisekunden 
ausgeben.

also

uint32_t timer =0;

while(1)
{

//printf ist Ausgabe per USART2
printf("Timer in MSec %i", timer);

}


wie bekomme ich dann >timer< alle 1msec oder 10msec  um eins erhoeht?

VG
Marcel

[Marcel (Gast)]

oder soll ich dafuer extra einen Timer erstellen der mir nen Interrupt 
erzeugt?

[Verwirrter Anfänger (Gast)]

Angenommen dein mtime hat eine Auflösung von 1ms, dann wäre die 
einfachste Lösung für einen delay:

void SysTick_Handler(void){
  TimValAdd();
}

void delayMs(uint32_t delay){
  uint32_t end = mtime+delay;
  while(mtime < end){
    // do nothing
  }
  return;
}

bzw. etwas modularer gehalten

void SysTick_Handler(void){
  TimValAdd();
}

uint32_t getMs(void){
  return mtime;
}


void delayMs(uint32_t delay){
  uint32_t end = getMs()+delay;
  while(getMs() < end){
    // do nothing
  }
  return;
}

Das ganze hat noch 2 Probleme:
- Ein Überlauf des Systick timers wird nicht beachtet, falls (mtime + 
end) > 2^32 ist hört die Funktion sofort auf
- Die Funktion ist nur auf 1mS genau. Ein delay(2) kann zwischen 1ms und 
2ms dauern.


Und um die Zeit ab einen beliebigen Start zu messen:

uint32_t start = getMs();

while(1){
  //printf ist Ausgabe per USART2
  printf("Timer in MSec %i", (getMs() - start));
}

[holger (Gast)]

>Ich wollte urspruenglich einfach nur einen Wert in millisekunden
>ausgeben.

Dann stell den Systick auf 1ms.

>wie bekomme ich dann >timer< alle 1msec oder 10msec  um eins erhoeht?

Entscheide dich mal. Alle 1ms oder alle 10ms?
Du zählst im Systick Interrupt eine Variable hoch.
Deren Wert holst du dir dann in deinem Programm. Fertig.