lpc1768 arm-non-eabi-gcc printf to uart0

[whoami (Gast)]

Hi,

ich schlage mich jetzt schon 3 Tage mit dem Thema rum aber komme einfach 
nicht weiter :(

Eigentlich will ich mit meinem lpc1768 (Mini-DK2) einfach nur per printf 
etwas an den UART0 ausgeben.

Der UART ansich funktioniert wunderbar wenn ich direkt chars an 
LPC_UART)->THR schreibe.

Wie ich das Ganze verstehe muss ich damit printf funktioniert einige 
syscalls wie _write und _sbrk implementieren. Das habe ich auch versucht 
... leider ohne Erfolg.

Zuerst habe ich in meinem Linker Script die Grenzen fuer einen heap 
Bereich festgelegt ...

/* define heap size */
heap_size = 256;

    .heap :
    {

    _heap_start = .;          /* Heap starts directly after bss section */
    . = . + heap_size;      
    _heap_end = .;                /* Heap end definition */

    } > RAM

Und danach die _write und _sbrk (fuer malloc) implementiert ...

#include <errno.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "lpc17xx.h"         /* for _get_PSP() from core_cm3.h*/

#undef errno
extern int errno;

extern char _heap_start;       /* Defined by the linker */
extern char _heap_end;         /* Defined by the linker */
static char *heap_curr = 0;

char* get_heap_end(void)
{
  return &_heap_end;
}

char* get_stack_top(void)
{
  return (char*) __get_MSP();
  // return (char*) __get_PSP();
}

int _write(int file, char *ptr, int len)
{
  int i;
  char *p = ptr;
  (void)file; /* avoid warning */

  for (i = 0; i < len; i++) {

    if ((*p) == '\n') {
      LPC_UART0->THR = '\r';
      while (!(LPC_UART0->LSR & (1U << 5)));
    }

    LPC_UART0->THR = (*p++);
    while (!(LPC_UART0->LSR & (1U << 5)));

  }

  return len;
}

caddr_t _sbrk(int incr)
{

  char *prev_heap_end;

  if (heap_curr == 0) {
    heap_curr = &_heap_start;
  }

  prev_heap_end = heap_curr;

  _write(1, "blabla\n", 7);
  return (caddr_t) prev_heap_end;

  char* top = get_stack_top();

#if 1
  if (heap_curr + incr > &_heap_end) {
    _write(1, "Heap Overflow!\n", 25);
  }
#endif

  heap_curr += incr;

  return (caddr_t) prev_heap_end;

}

int _close(int file)
{
  (void)file; /* avoid warning */
  return -1;
}

int _fstat(int file, struct stat *st)
{
  (void)file; /* avoid warning */
  st->st_mode = S_IFCHR;
  return 0;
}

int _isatty(int file)
{
  (void)file; /* avoid warning */
  return 1;
}

int _lseek(int file, int ptr, int dir) {
  (void)file; /* avoid warning */
  (void)ptr;  /* avoid warning */
  (void)dir;  /* avoid warning */
  return 0;
}

int _read(int file, char *ptr, int len)
{
  (void)file; /* avoid warning */
  (void)ptr;  /* avoid warning */
  (void)len;  /* avoid warning */
  return 0;
}

Leider rutsche ich jedesmal in die Heap <=> Stack Collition rein und 
mein eigentlicher Text wird nicht ausgegeben.

Hier meine main ...

#include <lpc17xx.h>
#include <stdio.h>

void initUART() {

  // setup uart0
  LPC_PINCON->PINSEL0 |= (1 << 4) | (1 << 6);
  LPC_UART0->LCR = 0x83;            // 8bit, no parity, 1 stop bit, DLAB=1
  LPC_UART0->DLL = 0x0D;            // divide by 13
  LPC_UART0->DLM = 0x00;
  LPC_UART0->LCR &= ~(0x01U << 7);      // disable DLAB
  LPC_UART0->IER |= (0x01U << 0);        // enable interrupt if data received
  LPC_UART0->FCR |= (0x01U << 0);        // enable fifo's
  LPC_UART0->FCR |= (0x02U << 6);        // interrupt if 8 char

  char* m = "Init Complete!\r\n";
  while(*m != '\0') {
    LPC_UART0->THR = *m++;
    while (!(LPC_UART0->LSR & (1U << 5)));
  }

  printf("test");
  printf("test");

}

int main(void) {

  SystemInit();
  SystemCoreClockUpdate();

  initUART();

  while(1) {

  }

  return 0;

}

Normalerweise sollte der Stack doch vom Ende des RAM's wachsen. Wieso 
habe ich dann schon bei einer 256Byte groesse des Heap eine collition?

Im Linker Script habe ich _stack_start = ORIGIN(RAM) + LENGTH(RAM); 
stehen.

Ich weis leider echt nicht mehr wo ich noch ansetzen soll.

Vielen Dank im voraus.

[S. R. (svenska)]

Mache den Heap größer. So 2048 Byte oder mehr. Wenn ich weniger 
einstelle, funktioniert bei mir nichtmal ein puts("abc"). Außerdem ist 
es guter Stil, in den ganzen anderen Syscall-Stubs errno passend zu 
setzen (ENOENT, EBADF oder EINVAL, notfalls ENOMEM).

Die Newlib puffert relativ kräftig. Wenn du deine Strings nicht mit \n 
abschließt, solltest du fflush(NULL) hinterherschießen, sonst wird dir 
u.U. nie was angezeigt.

Nachtrag: sbrk gibt den alten Wert des Breaks zurück, nicht den neuen. 
Und du solltest dir vielleicht mal den alten Break, den neuen Break und 
das Increment ausgeben lassen.

PS: Die ganzen "void(variable);" habe ich bei mir nicht, der Compiler 
spuckt trotzdem keine Warnungen dafür aus. Vermutlich optimiert er die 
Variablen direkt weg.

[whoami (Gast)]

Hey,

vielen Dank fuer deine Hilfe!

Nachdem ich den heap vergroessert hatte funktioniert printf. Meine 
collition detection hat allerdings noch einen fehler iwo.

Zu meiner sbrk:

ich fuehre ja eine variable mit der aktullen heap Position (heap_curr) 
welche ich mit _heap_start initialisiere, welche aus dem linker script 
kommt. Und als return geht die aktuelle heap pos bevor dem addieren von 
incr zurueck. Von daher mache ich das ja wie du gesagt hast oder?

mit dem fflush hast du auch recht :) habs gerade verifiziert :D

[S. R. (svenska)]

Ja. Ich fands nur etwas umständlich gelöst.
Grob aus dem Kopf (und ungetestet) sieht es bei mir so aus:

int _write(int file, char *ptr, int len)
{
  int todo = len;
  while(todo--) {
    if(*ptr == '\n')
      uart_putc('\r');
    uart_putc(*ptr++);
  }
  return(len);
}

extern const char _heap_start;
caddr_t _sbrk(int incr)
{
  static int heap_size = 0;

  if(&_heap_start + heap_size > HEAP_SIZE) {
    panic("out of memory");
  } else if(heap_size < 0) {
    panic("heap problem");
  }

  heap_size += incr;
  return((caddr_t)(&_heap_start + heap_size - incr));
}