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 :

1 2 3 4 5 6 7 8 9 10 11

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);

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

Auszug aus http://computer.howstuffworks.com/c33.htm

PHP-Code:

/* 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 :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

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[i] 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