malloc hard fault KEIL

[Colombo010 (Gast)]

Hallo, ich versuche einen Ringbuffer auf einem Cortex M0 (kl25z board) 
zu implementieren, wie er in der angehängten Datei nachzulesen ist.

Bei der Ausführung von malloc, springt der Prozessor aber in den 
HardFault_Handler. Woran kann das liegen. Habe im Startup File versucht 
die Heapsize einzustellen, hat aber nix gebracht.

; <h> Stack Configuration
;   <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Stack_Size      EQU     0x00000800

                AREA    STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem       SPACE   Stack_Size
__initial_sp    EQU     0x20002ff8


; <h> Heap Configuration
;   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Heap_Size       EQU      0x00000400


                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem        SPACE   Heap_Size
__heap_limit

Und wie muss man sich das mit

extern uint32_t HEAP$$Base;
extern uint32_t HEAP$$Limit;
uint32_t __HEAP_START = (uint32_t)&HEAP$$Base;
uint32_t __HEAP_END = (uint32_t)&HEAP$$Limit;

vorstellen, irgendwo muss ja in einem anderen File HEAP$$Base und 
HEAP$$Limit definiert sein. Mir fehlt einfach das Verständnis, was da 
wirklich vorgeht und was gemacht werden muss damit es richtig ist. 
Vielleicht kann man es ja auch ohne malloc lösen.Hoffe auf Anregungen 
und Tipps,Danke.

[Dr. Sommer (Gast)]

Bei 16kB RAM ist malloc so eine Sache. Versuche es ganz zu vermeiden. 
Musst du unbedingt während das Programm läuft verschiedene Ringbuffer 
zuvor unbekannter Größe anlegen und wieder löschen? Wenn nicht, legst du 
alle Ringbuffer fix mit bekannter Größe an (zB als globale Variablen) 
und sparst dir das malloc-Zeug komplett. zB so:

struct RingBuffer [
  char* data;
  size_t size;
};

char rb1Data [1024];
char rb2Data [64];
RingBuffer buffer1 = { rb1Data, 1024 };
RingBuffer buffer2 = { rb2Data, 64 };

void ringBufferInit (RingBuffer* b);
void ringBufferWrite (RingBuffer* b, char* data, size_t size);
void ringBufferRead (RingBuffer* b, char* data, size_t size);

In C++ mit Templates ginge das auch noch eleganter.

[Avr A. (colombo010)]

Hallo, danke für die schnelle Antwort, also ich will per UART senden und 
empfangen also reichen zwei Ringbuffer. Die Größe ist auch bekannt. ich 
möchte auch alle Daten in Strukturen ablegen, um diese einfacher zu 
verarbeiten.

zb soll

struct nam {
   int size;
   char nname[20];

} data;

in den TX_buffer geschrieben werden. dann soll das ganze rausgeschickt 
werden.

[Dr. Sommer (Gast)]

Dann funktioniert das ja mit meinem Vorschlag, musst diesen struct halt 
umcasten oder unions verwenden.

[Udo S. (urschmitt)]

Wie willst du nur mit einer Variable size wissen wo das erste Byte zum 
Lesen ist und wo das erste freie Byte zum Schreiben?

Wie soll diese Funktion
void ringBufferWrite (RingBuffer* b, char* data, size_t size);
funktionieren?

[Dr. Sommer (Gast)]

Jo die Implementation braucht natürlich noch Schreibpointer+Füllstand 
oder so im struct. Ich hatte nur die für die Fragestellung relevanten 
Dinge, nämlich Array-Pointer+Größe, hineingeschrieben.

Udo Schmitt schrieb:
> Wie soll diese Funktion funktionieren
Sie schreibt "size" bytes  aus "data" in den Ringbuffer.

[Avr A. (colombo010)]

Ja, habs jetzt sowie im folgenden Link gemacht,

http://www.tschallener.net/AVR/intr_usart.pdf

was mir noch unklar ist, wie ich ein Struct in den Buffer 
reingeschaufelt bekomme, wahrscheinlich ist es nix wildes, habe halt 
noch keine Jahrelange Programmiererfahrung

[Dr. Sommer (Gast)]

Mit casten:

struct nam;
nam.size = 5;
memcpy (nam.nname, "blubb");
ringBufferWrite (&buffer1, (char*) (&nam), sizeof (nam));

[Avr A. (colombo010)]

ok, kannst du viell die Funktion definieren komplett, wenns keine Mühe 
macht natürlich :)

[Dr. Sommer (Gast)]

Nä, die Mühe darfst dir selber machen :-P

[W.S. (Gast)]

avr avr schrieb:
> zb soll
>
> struct nam {
>    int size;
>    char nname[20];
>
> } data;
>
> in den TX_buffer geschrieben werden.

HÄ?
Was soll denn das? Wenn du irgendwas per UART senden willst, dann gewiß 
Chars und keine Structs, gelle?

Also, mal ganz von vorne:
Ein Ringpuffer ist ein Speicherbereich, der von zwei unterschiedliche 
Instanzen benutzt wird: die eine schreibt hinein und die andere liest 
heraus (ok, Computerdeutsch..). Dazu gibt's 2 Zeiger. Die Zeiger lesen 
dürfen beide Instanzen, schreiben darf aber nur jede Instanz ihren 
eigenen Zeiger.

Beispiel:

#define buffersize 128
char Buffer[buffersize]; // das ist der Ringpuffer
int rdz, wrz;            // das sind die Zeiger

void InitBuffer (void)
{ wrz = rdz = 0; }

bool IsBufferFull (void)
{ int i;
  i = (wrz+1) % buffersize;
  return (i == rdz);
}

void PutIntoBuffer (char c)
{ int i;
  i = (wrz+1) % buffersize;
  if (i==rdz)
  { tja, Puffer ist voll, also was angemessenes hier tun }
  Buffer[wrz] = c;
  wrz = i;
}

Das aufrufende Programm braucht nur die Funktionen zu kennen, nicht aber 
den eigentlichen Puffer und die Zeiger. Modulintern muß es natürlich 
noch ne Funktion geben, die den Krempel dann auch wieder aus dem Puffer 
abholt und verarbeitet. Ins Headerfile gehören also nur

 
extern void InitBuffer (void); 
extern bool IsBufferFull (void);
extern void PutIntoBuffer (char c);

Beide Instanzen müssen dabei logischerweise mit dem gleichen Datentyp 
arbeiten, also wenn du nen char Buffer[..] kreierst, dann passen da nur 
Char's rein, wenn du nen verrückten struct Buffer[..] hernimmst, dann 
passen da eben nur verrückte struct's rein. (Deine Idee mit dem struct 
ist Mist)


Dr. Sommer schrieb:
> Wenn nicht, legst du
> alle Ringbuffer fix mit bekannter Größe an (zB als globale Variablen)
> und sparst dir das malloc-Zeug komplett. zB so:
> struct RingBuffer [
>   char* data;
>   size_t size;
> };

Den Sinn deines "RingPuffer"s sehe ich überhaupt nicht ein, wozu diesen 
unnützen struct, der nicht mal ein wirklicher Ringpuffer ist? Und den 
auch noch in globale Variablen? Zum Aufblähen des Codes? Zum Züchten von 
Bugs? Zum Verwirren von Anfängern?

Gute Programme erkennt man daran, daß sie Funktionalität sinnvoll 
kapseln.
Das hier ist das Gegenteil davon:
> char rb1Data [1024];
> char rb2Data [64];
> RingBuffer buffer1 = { rb1Data, 1024 };
> RingBuffer buffer2 = { rb2Data, 64 };
>
> void ringBufferInit (RingBuffer* b);
> void ringBufferWrite (RingBuffer* b, char* data, size_t size);
> void ringBufferRead (RingBuffer* b, char* data, size_t size);
.. mal abgesehen davon, daß dir immer noch die wichtigsten Teile das 
Ringpuffers fehlen.

W.S.

[Avr A. (colombo010)]

Structs können Structs beinhalten gelle.
ließ mal den Code im Link, da ists mit lese und schreibzeiger, der 
Ringpuffer soll auch kein Struct sein, im Programm wird mit Structs 
gearbeitet und somit sollen die Bytes der Struktur in ein Ringpuffer, 
damit man man die Daten raussenden kann. Ich möchte also eine Funktion 
die den Buffer mit Inhalten aus dem Struct füllt.

[Karl H. (kbuchegg)]

W.S. schrieb:

>> struct RingBuffer [
>>   char* data;
>>   size_t size;
>> };
>
> Den Sinn deines "RingPuffer"s sehe ich überhaupt nicht ein, wozu diesen
> unnützen struct, der nicht mal ein wirklicher Ringpuffer ist? Und den
> auch noch in globale Variablen? Zum Aufblähen des Codes? Zum Züchten von
> Bugs? Zum Verwirren von Anfängern?
>
> Gute Programme erkennt man daran, daß sie Funktionalität sinnvoll
> kapseln.
> Das hier ist das Gegenteil davon:
>> char rb1Data [1024];
>> char rb2Data [64];
>> RingBuffer buffer1 = { rb1Data, 1024 };
>> RingBuffer buffer2 = { rb2Data, 64 };
>>
>> void ringBufferInit (RingBuffer* b);
>> void ringBufferWrite (RingBuffer* b, char* data, size_t size);
>> void ringBufferRead (RingBuffer* b, char* data, size_t size);
> .. mal abgesehen davon, daß dir immer noch die wichtigsten Teile das
> Ringpuffers fehlen.
>

Die Idee (wenn auch nicht komplett durchgezogen, die Schreib- Lesezeiger 
fehlen), dürfte gewesen sein, mehrere Ringbuffer mit unterschiedlichen 
Größen instatiieren zu können. Daher die struct für den Ringbuffer 
selbst, daher die Übergabe einer derartigen Struktur an die Funktionen.

> W.S.