Delay Funktion für STM32 Board?

[Ivan J. (ivan1987)]

Hallo,

ich übe mich in der c-Programmierung eines STM32 discovery bords.
In den Example Ordner ist ein Bsp GPIO-Toggle mit dem zwei LEDs blicken.
die Blink-Frequenz wird hierbei mit folgender Funktion beeinflusst.

void Delay(__IO uint32_t nCount)
{
  for(; nCount != 0; nCount--);
}

FRAGE:
Kann ich diese Funktion für eine definierte Wartezeit von z.B. 5ms 
verwenden?
Oder gibt es eine andere Möglichkeit eine definierte Warte-Funktion zu 
erstellen?

[abc (Gast)]

Ich würds mit systic timer machen, so gehts aber auch.

Hab vor kurzem ein Displaytech 162 im 8-Bit mode angesteuert mit dem 
STM32F10x, wennst den selben hast kann ich dir die Lib schicken.

[AVerr (Gast)]

Soviel ich mich erinnern kann, hing diese Funktion vom Systick Timer ab.
Man übergibt die Anzahl von Systick Takten, die gewartet werden soll,
also wenn der Systick jede ms tickt, würdest du mit Delay(5) 5ms warten.
Am Anfang der main Funktion wurde der Systick Timer eingestellt.

[Ivan J. (ivan1987)]

@abc: Danke, das Board hab ich auch.
Und ich bin auch dabei ein LCD-Modul im 8-bit mode anzusteuern, bin aber 
schon bei der Initialisierung hängen geblieben.
Kannst du mir das schicken?

[Ivan J. (ivan1987)]

Naja, die Funktion wird im Bsp mit
Delay(0xFFFFF);
aufgerufen, was eine Blinkrate von geschätzt 250ms ausmacht...

[abc (Gast)]

main:

volatile int32_t SysTickCnt=0;

int main(void)
{
  RCC_ClocksTypeDef   Clocks;
  SystemInit();

  RCC_GetClocksFreq(&Clocks);
  SysTick_Config( Clocks.HCLK_Frequency/1000 - 1 );  // 1000 Hz ( T=1ms)

  while(1)
  {

}
}

void Delay (unsigned long tick)
{  
  int32_t SysTickCntHold;
     SysTickCntHold = SysTickCnt;  
  while((SysTickCnt - SysTickCntHold ) <= tick );   // wait ca. 110us
}

LCD.c:

#include "stm32f10x.h"
#include <stdio.h>

extern void Delay (unsigned long tick);

void LCD_RS(uint8_t val)           // RS ... register select
{
  if(val)   GPIO_SetBits  (GPIOB, GPIO_Pin_0);
  else     GPIO_ResetBits(GPIOB, GPIO_Pin_0);
}


static void LCD_RW(uint8_t val)           // RW ... read/write
{
  if(val)   GPIO_SetBits  (GPIOC, GPIO_Pin_5);
  else     GPIO_ResetBits(GPIOC, GPIO_Pin_5);
}


static void LCD_E(uint8_t val)             // E ... enable
{
  if(val){
    GPIO_SetBits  (GPIOC, GPIO_Pin_4);
    Delay(1);  //SET_TO 8-Bit (1/3)
      GPIO_ResetBits(GPIOC, GPIO_Pin_4);
  }
  else GPIO_ResetBits(GPIOC, GPIO_Pin_4);
}

void LCD_Data(uint8_t val)           
{
   GPIO_ResetBits (GPIOA, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);
  if(val)  GPIOA->ODR |= val;  //GPIOA->BSRR=val;
     LCD_E(1);

}

// Schreibt einen String auf das LCD
 
void lcd_string( char *data )
{
    while( *data != '\0' )
        LCD_Data( *data++ );
}


// Setzt den Cursor in Spalte x (0..15) Zeile y (1..2) 
 
void lcd_setcursor( uint8_t x, uint8_t y )
{
    uint8_t data;
 
    switch (y)
    {
        case 1:    // 1. Zeile
            data = 0x80 + 0x00 + x;
            break;
 
        case 2:    // 2. Zeile
            data = 0x80 + 0x40 + x;
            break;
        default:
            return;                                   // für den Fall einer falschen Zeile
    }
    LCD_RS(0);
    LCD_Data( data );
  LCD_RS(1);
}

void LCD_Init(void)
{
  GPIO_InitTypeDef  GPIO_InitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE);

    GPIO_InitStruct.GPIO_Pin    =  GPIO_Pin_0;      // RS
  GPIO_InitStruct.GPIO_Speed  =  GPIO_Speed_10MHz;
  GPIO_InitStruct.GPIO_Mode    =  GPIO_Mode_Out_PP;
  GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.GPIO_Pin    =  GPIO_Pin_4|GPIO_Pin_5;    //En and R/W
  GPIO_InitStruct.GPIO_Speed  =  GPIO_Speed_10MHz;
  GPIO_InitStruct.GPIO_Mode    =  GPIO_Mode_Out_PP;
  GPIO_Init(GPIOC, &GPIO_InitStruct);

    GPIO_InitStruct.GPIO_Pin    = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;      // Datenports Display
  GPIO_InitStruct.GPIO_Speed  =  GPIO_Speed_10MHz;
  GPIO_InitStruct.GPIO_Mode    =  GPIO_Mode_Out_PP;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_ResetBits(GPIOB, GPIO_Pin_0);
  GPIO_ResetBits(GPIOC, GPIO_Pin_4 | GPIO_Pin_5);
  GPIO_ResetBits(GPIOA, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);
     
  /* DISPLAY INITIALISATION */
  LCD_RW(0);

  Delay(15);  //wait ca 15ms
  LCD_Data(0x30);    //SET_TO 8-Bit (1/4)
  Delay(5);  //wait more than 4,2ms
  LCD_Data(0x30);    //SET_TO 8-Bit (2/4)
  Delay(1);  //wait more than 110us
  LCD_Data(0x30);    //SET_TO 8-Bit (3/4)
  LCD_Data(0x30);    //SET_TO 8-Bit (4/4)
   
  LCD_Data(0x38);    //2-Line Display
  LCD_Data(0x08);    //Display Off

  LCD_Data(0x01);    //Delete Display

  LCD_Data(0x03);    //Cursor Right

  LCD_Data(0x06);    //Display On

  lcd_setcursor(0,0);    //Cursor 0/0
   
   LCD_Data(0x0C);    //Display On

   LCD_RS(1);
     
}

[abc (Gast)]

Den auch noch in die main packen:

void SysTick_Handler(void)
{
  SysTickCnt++;
}

[frage (Gast)]

Gibt es ein gutes tutorial zum stm32 oder eventuell ein Buch.das mir 
empfohlen werden könnte?

[abc (Gast)]

nein, aber wenn du dich gut mit µ-Cs auskennst kann ich dir paar 
einfache gut dokumentierte Programmierbeispiele schicken, den rest 
findet man im Referenzmanual

[Roland H. (batchman)]

Ivan Jast schrieb:
> void Delay(__IO uint32_t nCount)
> {
>   for(; nCount != 0; nCount--);
> }

Das ist Pfusch - vor allem auf einem stm32, welcher massig Timer zur 
Verfügung stellt.

abc schrieb:
> main:
> volatile int32_t SysTickCnt=0;

Kann es sein, dass da die ISR fehlt?

> void Delay (unsigned long tick)
> {
>   int32_t SysTickCntHold;
>      SysTickCntHold = SysTickCnt;
>   while((SysTickCnt - SysTickCntHold ) <= tick );   // wait ca. 110us
> }

Wo wird der Zählerüberlauf beachtet? Was bedeutet der Kommentar?

EDIT: Die ISR ist inzwischen eingetrudelt. Aber wo wird der Überlauf des 
Zählers behandelt?

[Ivan J. (ivan1987)]

Danke für den Code! Ich werd ihn mal für meine Pins anpassen...

abc schrieb:
> Den auch noch in die main packen:
> void SysTick_Handler(void)

die Fkt ist (laut Fehler) schon in stm32f10x_it.c definiert... ohne sie 
gibts auch keinen Fehler.

[Karl H. (kbuchegg)]

Roland H. schrieb:

>> void Delay (unsigned long tick)
>> {
>>   int32_t SysTickCntHold;
>>      SysTickCntHold = SysTickCnt;
>>   while((SysTickCnt - SysTickCntHold ) <= tick );   // wait ca. 110us
>> }
>
> Wo wird der Zählerüberlauf beachtet? Was bedeutet der Kommentar?
>
> EDIT: Die ISR ist inzwischen eingetrudelt. Aber wo wird der Überlauf des
> Zählers behandelt?

Da hier unsigned gerechnet wird, braucht man sich um 1 Überlauf nicht 
kümmern. Mehrere dürfen es allerdings nicht sein.

[frage (Gast)]

@Abc also IDE programmer geht alles nur mit der stm lib kenn ich mich 
nicht aus! Erfahrung hab ich einiges mit avr.und 8051

[abc (Gast)]

@ ivan, in der it datei passt natürlich auch
Wichtig ist dass du die SysTickCnt variable definierst und im IR handler 
erhöhst.

 SysTickCnt++;

Übern überlauf hab ich mir noch wenig gedanken gemachtr.

[Stefan von Bölde (Gast)]

Ich habe mich an dieses Tutorial mit Beispielen gehalten:
http://en.radzio.dxp.pl/stm32vldiscovery/

[Klaus S. (skibby)]

Ich habe das so realisiert:

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

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

void delay_ms(uint16_t time_ms)
{
  while (time_ms>0)
  {
    delay_us(1000);
    time_ms--;
  }
}

[abc (Gast)]

bei deinem Problem:

  if(val)  GPIOA->ODR |= val;  //GPIOA->BSRR=val;
     LCD_E(1);



Das es verkehrt herum ist, Probier mal:

  val = ( ((uint16_t)val) >> 8 ) | ( val << 8 );

[abc (Gast)]

Das sollte funktionieren:

int bit_reverse(int in) {
  int rev=0;
  int i;

  for (i = 0; i < BIT_WIDTH; i++) {
   rev = (rev << 1) | (in & 1);
   in >>=1;
  }
  return rev;
}

[Ivan J. (ivan1987)]

Jawohl :-)
dein Code funktioniert!! Herzlichen Dank!!!

Ich musste nur die Bitreihenfolge der Datenbits ändern, weil ich die 
andersrum angeschlossen hab (DB0 : PA7 usw), das geht mit folgendem 
Algorithmus am Anfang der LCD_Data Funktion:

  uint8_t temp1 = 0x00;
  uint8_t temp2 = 0x00;
  int i;
  for (i = 0; i<=7; i++) 
  {
    temp1 = val << i;
    temp1 = temp1 >> 7;
    temp1 = temp1 << i;
    temp2 = temp1 | temp2;
  }
  val = temp2;

[kremsy (Gast)]

schön ;)

[Felix d. (inqui85)]

abc schrieb:
> Ich würds mit systic timer machen, so gehts aber auch.
>
> Hab vor kurzem ein Displaytech 162 im 8-Bit mode angesteuert mit dem
> STM32F10x, wennst den selben hast kann ich dir die Lib schicken.

Moin Zusammen!

Bin grad am Basteln mit genau dem LCD,
habe auch ungefähr das selbe Problem mit der Initialisierung...

Möchte mir jemand mla einen Beispielcode/Project zur verfügung stellen, 
dann könnte cih vergleiche wie ihr das gemacht habts...