dynamische Speicherverwaltung unter C mit malloc und free?

uli-tt

Grünschnabel
Ich möchte Daten dynamisch speichern unter C und weiterleiten.

Ich habe einen schleife bei der ich 8 unsind char (hex) über einen Bus einlese.
Diese Daten möchte ich jetzt mit malloc speichern, nur wie funktioniert das?

Hat da mal einer ein gutes Beispiel wie man so ein FIFO realisiert?

Uli
 
Das ist nun nicht ein FIFO, denn das wäre eine Art Stack. Doch wenn du 8 char Werte brauchst, dann kannste immernoch auf jeden einzeln zugreifen.


Code:
int x;
char abc = 'A';
char * c;
c = (char *) malloc( sizeof(char) * 8 );

for( x=0; x<8; x++ ) {
   c[x] = abc++;
}

for( x=0; x<8; x++, c++ )
    free(c);
 
ANSI C - Stack Beispiel

So ich hab Dir da mal ein Beispiel einer Realisierung eines stacks herausgesucht:


PHP:
/* Stack Library - This library offers the
   minimal stack operations for a
   stack of integers (easily changeable) */

typedef int stack_data;

extern void stack_init();
/* Initializes this library.
   Call first before calling anything. */

extern void stack_clear();
/* Clears the stack of all entries. */

extern int stack_empty();
/* Returns 1 if the stack is empty, 0 otherwise. */

extern void stack_push(stack_data d);
/* Pushes the value d onto the stack. */

extern stack_data stack_pop();
/* Returns the top element of the stack,
   and removes that element.
   Returns garbage if the stack is empty. */

########################################
// The library's code file follows: 
------------------------------------

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

/* Stack Library - This library offers the
   minimal stack operations for a stack of integers */

struct stack_rec
{
    stack_data data;
    struct stack_rec *next;
};

struct stack_rec *top=NULL;

void stack_init()
/* Initializes this library.
   Call before calling anything else. */
{
    top=NULL;
}

void stack_clear()
/* Clears the stack of all entries. */
{
    stack_data x;

    while (!stack_empty())
    x=stack_pop();
}

int stack_empty()
/* Returns 1 if the stack is empty, 0 otherwise. */
{
    if (top==NULL)
        return(1);
    else
        return(0);
}

void stack_push(stack_data d)
/* Pushes the value d onto the stack. */
{
    struct stack_rec *temp;
    temp=
  (struct stack_rec *)malloc(sizeof(struct stack_rec));
    temp->data=d;
    temp->next=top;
    top=temp;
}

stack_data stack_pop()
/* Returns the top element of the stack,
   and removes that element.
   Returns garbage if the stack is empty. */
{
    struct stack_rec *temp;
    stack_data d=0;
    if (top!=NULL)
    {
        d=top->data;
        temp=top;
        top=top->next;
        free(temp);
    }
    return(d);
}
 
-

Hallo,
beim FIFO Prinzip handelt es sich nicht um einen Stack - dass wäre das LIFO Prinzip, sondern um eine Queue. Die Elemente werden an das Ende der Liste geschrieben und vom Anfang wieder entfernt.

Gruß Patrick
 
Ja ein FIFO ist eine QUEUE, doch wie programmiere ich sowas?

Ich habe 2 for Schleifen die 16mal insgesammt aufgerufen werden. Die Anzahl wie oft jede einzelne Schleife aufgerufen wird variirt zwischen 0..16, die Gesamtanzahl beider Schleifen ist immer 16 (Entweder wird ein Befehl gesetzt oder zurückgesetzt).
In dieser Schleife werden jeweils 8 Daten (unsigned char (hex)) vom CAN BUS eingelesen und in dem FIFO gespeichert. Diese gespeicherten Daten werden dann aus dem FIFO an eine weitere Leiterkarte mit einer anderen Adresse unverändert über den CAN Bus gesendet.

Das Einlesen und Weitergeben funktioniert, aber wie speichere ich die Eingelesenen Daten ab und rufe diese wieder auf um sie weiterzuleiten?

Es handelt sich um Hardwarenahe Programmierung.

Ich hatte wie gesagt an init_mempool (muß als 1. verwendet werden) und molloc oder calloc gedacht. Es wird ein C51 Compiler unter Keil verwendet.
Es währe auch eine typdef möglich.

Ich bin nur Anfänger und habe beides noch nicht gemacht, also Vorschläge?

Ich hoffe ich habe das Problem genau genug beschrieben ohne zu viel zu schreiben?

Uli
 
Sag mal uli-tt, du hast doch genau das gleiche im letzten Thread schon gefragt und ich hab dir ne Realisierung hingeschrieben!
 
Lösungsansatz sieht so aus:

Code:
unsigned char xdata malloc_mempool [0x1000]; //Größe des Speichers
unsigned int LAENGE_StimuMa 256		//Variablen Def. für Größe des 1. FIFO

main()
{
  init_mempool (&XBYTE [0x2000], sizeof(malloc_mempool));       //**Def. wo gespeichert wird und wiefiel speicherplatz zur verfügung steht. Alos hir ab Adresse 0x2000 für 1000hex Daten.**/
    
  /* HAUPTKONTROLLSCHLEIFE */
  while(1)
	{
	get_command();
	}  
}
//**************
void get_command(void)

//**reset_stimu_matrix vom 
if (can_rx.des == stim_reset)
{
byte* puffer = (byte*)malloc(LAENGE_StimuMa);
byte* anfang = puffer;
byte* ende = puffer;

int i,menge=0; 

    for (i = 0; i < 8; i++) // Daten vom CAN BUS lesen
	{
	 if (menge < LAENGE_StimuMa) // nur schreiben,wenn Puffer nicht voll
		{
		*ende = can_rx.dat[i]; //CAN Bus Daten in FIFO speichern
		if (++ende >= (puffer+LAENGE_StimuMa)) ende = puffer;
		menge++;
		}
	}
    	
	for (i=0; i < 8; i++)
	{
	if (menge > 0) //nur lesen, wenn nicht leer
		{
		can_tx.dat[i+1] = *anfang; //CAN Bus Daten vom FIFO lesen
		if (++anfang >= (puffer+LAENGE_StimuMa)) anfang = puffer; //Zeiger neu setzen
		menge++;
		}
	}
 
	delay(30); //Zykluszeit 30ms
	can_tx.des = reset_stimu_matrix; //Def. an welche Adresse gesendet wird
	tx_data();			//Daten auf CAN Bus senden
	free (anfang_r);	//dynamischen Speicher freigeben für malloc
	free (ende_r);
	}
}

Problem beim Einlesen in den FIFO: Der Zeiger wird beim Durchlaufen der for Schleife zwar stufenweiße mit i++ erhöht, aber der Inhalt von can_rx.dat wird nicht in den Speicher geschrieben!
Ich habe also nur einen Zeiger aber keinen Inhalt!
Woran kann das liegen?

BUFFER geht nicht da Hardware nur 2 Werte buffert!

Uli
 
Zuletzt bearbeitet von einem Moderator:
Zurück