printf problem bei STM32F4

[Stm M. (stmfresser)]

Hallo,

ich habe ein seltsames Problem mit printf beim Programmieren STM32F4 
Discovery Board.

Nur beim Printen von mehreren Gleitkommazahlen bekomme ich entweder ganz 
verfälschte Daten, oder die nur die Hälfte, wenn ich in main schleife 
nach dem printf ohne mindestens 200ms Verzögerung habe. Mit 200ms Delay 
geht printf ohne Problem. Woran liegt das? Ist mein printf keine 
blockierende Methode?


Vielen Dank im Voraus.

PS. Ich schreib deutsch als Fremdsprache. Entschuldigung für die 
schlechtformulierten Sätze.

int main(void){

while(1){
 printf("%f %f %f %f \n", zahl1, zahl2, zahl3, zahl4);
 Delay(200e3);
}
}

void Delay(__IO uint32_t nTime)
{
    TimingDelay = nTime;
    
    while(TimingDelay != 0);
}

void TimingDelay_Decrement(void)
{
    if (TimingDelay != 0x00)
    {
        TimingDelay--;
    }
}

Usart wird so konfiguriert.

 
/* USART1 clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

/* USART1 initialisieren PB6=TX PB7=RX*/
GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_USART1);  GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_USART1);
    
   
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;  
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;  
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);


USART_InitTypeDef USART_InitStructure;
    
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
    
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  
USART_Init(USART1, &USART_InitStructure);
USART_Cmd(USART1, ENABLE);

/**
 * @brief  Retargets the C library printf function to the USART.
 *       Overwrite __io_putchar function used by printf
 * @param  None
 * @retval None
 */
PUTCHAR_PROTOTYPE
{
  /* Put character on the serial line */
  USART1->DR = (ch & (uint16_t)0x01FF);
    
  /* Loop until transmit data register is empty */
  while ((USART1->SR & USART_FLAG_TXE) == (uint16_t) RESET);
    
  return ch;
}

für Prinf float zahlen

#include <errno.h>
#include <sys/stat.h>
#include <sys/times.h>
#include <sys/unistd.h>
#include <stdint.h>

#include <stm32f4xx_usart.h>

#ifndef UNUSED
#define UNUSED(x) (void)x
#endif

#ifndef STDOUT_USART
#define STDOUT_USART 1
#endif

#ifndef STDERR_USART
#define STDERR_USART 2
#endif

#ifndef STDIN_USART
#define STDIN_USART 1
#endif

#undef errno
extern int errno;

/*
 * A pointer to a list of environment variables and their values.
 * For a minimal environment, this empty list is adequate.
 */
char *__env[1] = { 0 };
char **environ = __env;

int _write(int file, char *ptr, int len);

void _exit(int status) {
  UNUSED(status);

  _write(1, "exit", 4);
  while (1) {
    ;
  }
}

int _close(int file) {
  UNUSED(file);

  return -1;
}

/*
 * Transfer control to a new process. Minimal implementation (for a system
 * without processes)
 */
int _execve(char *name, char **argv, char **env) {
  UNUSED(name);
  UNUSED(argv);
  UNUSED(env);

  errno = ENOMEM;
  return -1;
}

/*
 * Create a new process. Minimal implementation (for a system without processes)
 */
int _fork() {
  errno = EAGAIN;
  return -1;
}
/*
 * Status of an open file. Minimal implementation.
 */
int _fstat(int file, struct stat *st) {
  UNUSED(file);

  st->st_mode = S_IFCHR;
  return 0;
}

/*
 * Process-ID; this is sometimes used to generate strings unlikely to conflict
 * with other processes. Minimal implementation, for a system without processes.
 */
int _getpid() {
  return 1;
}

/*
 * Query whether output stream is a terminal. For consistency with the other
 * minimal implementation.
 */
int _isatty(int file) {
  UNUSED(file);

  switch (file) {
  case STDOUT_FILENO:
  case STDERR_FILENO:
  case STDIN_FILENO:
    return 1;
  default:
    //errno = ENOTTY;
    errno = EBADF;
    return 0;
  }
}

/*
 * Send a signal. Minimal implementation.
 */
int _kill(int pid, int sig) {
  UNUSED(pid);
  UNUSED(sig);

  errno = EINVAL;
  return (-1);
}

/*
 * Establish a new name for an existing file. Minimal implementation.
 */
int _link(char *old, char *new) {
  UNUSED(old);
  UNUSED(new);

  errno = EMLINK;
  return -1;
}

/*
 * Set position in a file. Minimal implementation.
 */
int _lseek(int file, int ptr, int dir) {
  UNUSED(file);
  UNUSED(ptr);
  UNUSED(dir);

  return 0;
}

/*
 * Increase program data space. Malloc and related functions depend on this.
 */
caddr_t _sbrk(int incr) {

  extern char _ebss; // Defined by the linker
  static char *heap_end;
  char *prev_heap_end;

  if (heap_end == 0) {
    heap_end = &_ebss;
  }
  prev_heap_end = heap_end;

  /** FIX **/
    char * stack = (char*) __get_MSP();
    if (heap_end + incr >  stack){
      _write (STDERR_FILENO, "Heap and stack collision\n", 25);
      errno = ENOMEM;
      return  (caddr_t) - 1;
      //abort ();
    }

  heap_end += incr;
  return (caddr_t) prev_heap_end;

}

/*
 * Read a character to a file. `libc' subroutines will use this system routine
 * for input from all files, including stdin.
 * Returns -1 on error or blocks until the number of characters have been read.
 */
int _read(int file, char *ptr, int len) {
  int n;
  int num = 0;
  switch (file) {
  case STDIN_FILENO:
    for (n = 0; n < len; n++) {
#if   STDIN_USART == 1
      while ((USART1->SR & USART_FLAG_RXNE) == (uint16_t)RESET) {}
            char c = (char)(USART1->DR & (uint16_t)0x01FF);
#elif STDIN_USART == 2
//      while ((USART2->ISR & USART_FLAG_RXNE) == (uint16_t) RESET) {}
//      char c = (char) (USART2->TDR & (uint16_t) 0x01FF);
#elif STDIN_USART == 3
//      while ((USART3->ISR & USART_FLAG_RXNE) == (uint16_t)RESET) {}
//      char c = (char)(USART3->TDR & (uint16_t)0x01FF);
#endif
      *ptr++ = c;
      num++;
    }
    break;
  default:
    errno = EBADF;
    return -1;
  }
  return num;
}

/*
 * Status of a file (by name). Minimal implementation.
 * int _EXFUN(stat,( const char *__path, struct stat *__sbuf ));
 */
int _stat(const char *filepath, struct stat *st) {
  UNUSED(filepath);

  st->st_mode = S_IFCHR;
  return 0;
}

/*
 * Timing information for current process. Minimal implementation.
 */
clock_t _times(struct tms *buf) {
  UNUSED(buf);

  return -1;
}

/*
 * Remove a file's directory entry. Minimal implementation.
 */
int _unlink(char *name) {
  UNUSED(name);

  errno = ENOENT;
  return -1;
}

/*
 * Wait for a child process. Minimal implementation.
 */
int _wait(int *status) {
  UNUSED(status);

  errno = ECHILD;
  return -1;
}

/*
 * Write a character to a file. `libc' subroutines will use this system routine
 * for output to all files, including stdout.
 * Returns -1 on error or number of bytes sent.
 */
int _write(int file, char *ptr, int len) {
  int n;

  switch (file) {
  case STDOUT_FILENO: /*stdout*/
    for (n = 0; n < len; n++) {
      while ((USART1->SR & USART_FLAG_TXE) == (uint16_t)RESET) {
                //USART1->DR = (*ptr++ & (uint16_t)0x01FF);
            }
      USART1->DR = (*ptr++ & (uint16_t)0x01FF);
    }
    break;
  case STDERR_FILENO: /* stderr */
    for (n = 0; n < len; n++) {

    }
    break;
  default:
    errno = EBADF;
    return -1;
  }
  return len;
}

[Rufus Τ. F. (rufus)]

Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

[foobar (Gast)]

Ich hab keine Ahnung, wie das C-Library deines Systems aufgebaut ist. 
Eine Sache ist mir bei deiner Patcherei aber aufgefallen: der 
PUTCHAR_PROTOTYPE und die _write Routine sind nicht kompatibel.  Der 
Prototype schreibt das Zeichen in das TX-Register und wartet dann auf TX 
Empty, die _write Routine macht es umgekehrt.  Wenn nun direkt nach 
einem Aufruf von _write ein PUTCHAR folgt, wird das gerade übertragene 
Zeichen überschrieben.  Beide Routinen sollten die gleiche Reihenfolge 
benutzen.

[Stm M. (stmfresser)]

seltsamerweise funktioniert printf mit einer Verzögerung mind. 200ms in 
main-Schleife.

Wenn man die Verzögerung rausnimmt, dann bekomme ich entweder Char-Brei 
oder die Hälfte, was man gesendet hat.

Als Compiler und Linker wird GCC ARM Embedded - Launchpad benutzt.

LG