STM32 String senden über Uart

[Sascha (Gast)]

Guten Morgen,
ich bin gerade dabei mich mit den STM32 ARM anzufreunden aber irgendwie
mögen die mich nicht naja ... wie dem auch sei ... hir mein Problem:

ich habe ein Struct mit dem start ich die init der uart2 (115200 Baud
8N1) geht wunderbar. funktion um ein char zu denden:

 void u2_putchar(char c)
{   
  while (!(USART2->SR & (1<<7)));  //bit 7 = TX ready
    USART2->DR = (c);

}

geht auch ... zb:

u2_putchar('T');
u2_putchar('e');
u2_putchar('s');
u2_putchar('t');
u2_putchar(0x0A);

will ich jetzt aber ein string senden habe ich das mit den AVR's so
gemacht:

void USART_Transmit_S(char *data)
{
    while(*data) {
        USART_Transmit(*data);
        data++;
    }
}

.
.
.

uint8_t text[] = "Das ist ein Test";

USART_Transmit_S(test);

ist jetzt nicht das 7 weltwunder geht aber.

also dachte ich mir C ist C so änlich wird es auch mit einem STM32 gehen
...
ich benutze die Ride 7 als IDE und R-Link STX als debuger das geht
eigendlich wunderbar ...

also habe ich es wieder änlich aufgebaut:

void u2_putstring(const char *s)
{   
  while(*s) u2_putchar(*s++);  // send string char by char
}

tja das geht glaub ich auch ABER wenn ich mir jetzt ein buffer definire:
uint8_t buffer[] = "text...";

und mir mit dem debuger den Buffer angucke steht da nur 0xFF drin ...
dann komm ich natürlich nicht mehr als der schleife...was muss ich den
jetzt anderst machen damit das geht?

ps sowas geht auch:
uint8_t buffer [] = { 0x01, 0x02, 0x03, ... };

viel dank schonmal
Sascha

ps.: sry für den repost mir ist aber aufgefallen das das eher ins GCC 
forum gehört als ins µC

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x_conf.h"
#include <stdio.h>
#include <string.h>

GPIO_InitTypeDef GPIO_InitStructure;


void RCC_Configuration(void);
void NVIC_Configuration(void);
void Delay(vu32 nCount);



#define UART2_TX_PIN    5;
#define UART2_RX_PIN    6;

#define UART2_GPIO      GPIOD;
#define UART1_CLK_EN    14;  
#define UART2_CLK_EN    17; 
#define UART_EN         13;
#define UART_RX_EN      2;
#define UART_TX_EN      3;
#define TXE          7;  // TX Reg empty
#define UART_M    12;  // 

typedef struct 
    {
    int32_t     UART_CLK;
    int32_t     BAUD;
    uint8_t     DATA_BITS;
    uint8_t     STOP_BITS;
    uint8_t     PARITY;
}UART_INITSTRUCT;


void UART_INIT(UART_INITSTRUCT* initstruct)
{
        
    uint16_t    baud_temp   =   initstruct->UART_CLK/(initstruct->BAUD*16);
    uint16_t    baud_temp2  =   ((initstruct->UART_CLK / (initstruct->BAUD*16/100) - baud_temp*100) * 16 + 5) /100;
    baud_temp2             |=   baud_temp<<4;

    /* Enable GPIOD clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);

    GPIO_InitStructure.GPIO_Pin   =  1<<UART2_TX_PIN;
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOD, &GPIO_InitStructure);
      
    GPIO_InitStructure.GPIO_Pin   =  1<<UART2_RX_PIN;
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOD, &GPIO_InitStructure);

   
    RCC->APB2ENR    |=  (1<<0);
    RCC->APB1ENR    |=  1<<UART2_CLK_EN;   
    
    USART2-> BRR   =     baud_temp2;   
  
    USART2->CR1     |=  1<<UART_TX_EN;
    USART2->CR1     |=  1<<UART_RX_EN;
    USART2->CR1     |=  1<<UART_EN;    

    AFIO->MAPR      |=  (1<<3);
}


void u2_putchar(char c)
{   
  while (!(USART2->SR & (1<<7))); //bit 7 = TX ready
    USART2->DR = (c);

}

void u2_putstring(const char *s)
{   
  while(*s) u2_putchar(*s++);  // send string char by char
}





int main(void)
{
#ifdef DEBUG
  debug();
#endif

  /* System Clocks Configuration */
  RCC_Configuration();

  /* NVIC Configuration */
  NVIC_Configuration();


   // UART_INITSTRUCT.UART        =   "UART2";
    UART_INITSTRUCT     UART2;
    UART2.UART_CLK    =   36000000;
    UART2.BAUD        =   115200;


    UART_INIT(&UART2);



    uint8_t  daten[] = "Das ist ein String Test";

    
    long long int delay = 10000;
  while(1)
  {
    u2_putstring(daten);
    
    u2_putchar(0x0A);
       
    
    /* Insert delay */
    Delay(delay*10);
  }
}

void RCC_Configuration(void)
   {
   //Clock control register
  RCC->CR  = RCC_CR_HSEON ;       //HSE on

  // Wait for HSE
  while (!(RCC->CR & RCC_CR_HSERDY))
  {
  }

  //setup PLL 8Mhz in 72Mhz Sys Clock
 
  //Clock configuration register
  RCC->CFGR     |= RCC_CFGR_PLLSRC;         //HSE als PLL-Eingangssignal
  RCC->CFGR     |= RCC_CFGR_PLLMULL9;       //PLL=HSE*9
  RCC->CR       |= RCC_CR_PLLON;            //PLL einschalten 

  //Wait for PLL
  while (!(RCC->CR & RCC_CR_PLLRDY))
  {
  }

  RCC->CFGR      = RCC_CFGR_SW_PLL;          //PLL als Systemtakt
  
  //Wait for SYSCLK
  while (!(RCC->CFGR & RCC_CFGR_SWS_PLL))
  {
  }
  //Takte für die Peripherie einschalten
  RCC->CFGR     |= RCC_CFGR_PPRE1_DIV2;     //APB1 /2 teilen
  RCC->CFGR     |= RCC_CFGR_PPRE2_DIV1;     //APB2 /1 teilen   

      {;}  
   }


void NVIC_Configuration(void)
{
#ifdef  VECT_TAB_RAM  
  /* Set the Vector Table base location at 0x20000000 */ 
  NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); 
#else  /* VECT_TAB_FLASH  */
  /* Set the Vector Table base location at 0x08000000 */ 
  NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
#endif
}

void assert_failed(u8* file, u32 line)
{ 
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* Infinite loop */
  while (1)
  {
  }
}


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

[Sascha (Gast)]

humm also ich habes es jetzt "überredet"

ich muss mir den string vor der main rutine definiren:

void u2_putchar(char c)
{   
  while (!(USART2->SR & (1<<7)));
    USART2->DR = (c);
}

void u2_putstring(const char *s)
{   
  while(*s) u2_putchar(*s++);  // send string char by char
}

uint8_t  daten[]  = "Das ist ein String Test";  

int main(void)
{
#ifdef DEBUG
  debug();
#endif

  /* System Clocks Configuration */
  RCC_Configuration();

  /* NVIC Configuration */
  NVIC_Configuration();

   // UART_INITSTRUCT.UART        =   "UART2";
    UART_INITSTRUCT     UART2;
    UART2.UART_CLK    =   36000000;
    UART2.BAUD        =   115200;

    UART_INIT(&UART2);

    long long int delay = 10000;

  while(1)
  {   
    u2_putstring(daten);
    u2_putchar(0x0A);
       
    /* Insert delay */
    Delay(delay*10);
  }
}

schon gehts ... aber wenn ich jetzt inerhalb der main das gleiche mache 
gehts nicht O_o kann mir das mal einer erklären?

[Sascha (Gast)]

edit:
so etwas zb geht nicht:

[c]
.
.
.
  while(1)
  {
    u2_putstring("test");

    u2_putchar(0x0A);


    /* Insert delay */
    Delay(delay*10);
  }
[\c]

[Karl H. (kbuchegg)]

Das klingt nach einer Spezialität deines Compilers.
Hast du schon Handbuch gestöbert?

[Sascha (Gast)]

erlichgesagt nein, die Raisonance IDE (Ride7) ist mir noch recht neu 
aber bis auf dies problem war ich bis jetzt eigendlich sehr zufirden 
damit.