FIFO unter C51(Keil) erstellen

[uli-tt]

Hi,

Ich benötige einen FIFO speicher um Daten zwischenzuspeichern.

Ich habe 2 Leiterkarten. Die eine wird vom PC über CAN angesprochen und soll die gesendeten Daten speichern. Diese Daten sollen mit einer anderen Übertragunsrate an die 2. Karte über CAN-Bus weitergeleitet werde.
Die Kommunikation klappt, aber wie baue ich den FIFO auf? Habe da an init_mempool, colloc, malloc und free gedacht, habe nur keinen Plan

Es wird ein alter 80c592 Prozessor verwendet und mit Keil C51 wird programmiert.

Hoffe mir kann da wer weiterhelfen.

Uli

 

[uli-tt]

//****Einlesen des Can-Busens in Speicher**************

if(can_rx.des == stim_setzen) //Wenn bedingung erfüllt CAN Daten in FIFO einlesen und Weiterleiten

   {
        		byte i;
	for (i=0; i!=8; i++)	//Wie speichere ich die CAN BUS Daten? Es können bis zu 16 can_rx.dat[i] gesendet werden
	
{
		 
	rx(n) = can_rx.dat[i];	//CAN Bus Daten vom PC  Zwischenstpeichern
	n=n+1;
	}	

//****Auslesen des Speichers und senden an Knoten**************

//Wie lese ich den Speicher aus
	for (i=0; i!=8; i++)
	{
	 can_rx.dat[i] = rx(n);		//CAN Bus Daten zum Knoten
	}

		can_tx.des=set_stimu_matrix;
	tx_data();			//Daten auf CAN Bus senden
	}
}

Kann mir mal jemand erklären wie ich die über den CAN BUS gesendeten Daten dynamisch zwischenspeichern kann
und die Daten über den CAN BUS an eine weiter Leiterkarte senden kann

Uli

 

[Dudadida]

Ähm, also der Quellcode ist wohl ein wenig komplizierter, glaube nicht, dass hier viele Leute Lust haben (ich eingeschlossen), sich da jetzt hinzusetzen und ihn auseinander zu nehmen. Was den FIFO Puffer angeht, naja, da kann man sich doch ein Zirkulationssystem überlegen:
drei Zeiger: einer für den Anfang des reservierten Speichers, einer für das aktuell erste Element, einer für das aktuell letzte Element. Wenn ein Element hinzugefügt wird, wird der Zeiger auf das letzte Element erhöht (nachdem das Element vorher an die Stelle auf die er zeigt eingefügt wurde), wenn eins gelesen wird, wird der auf das erste Element erhöht. Kommt einer von beiden ans Ende, wird er wieder auf den Speicheranfang gesetzt, die Zeiger dürfen nur nie auf das gleiche Element zeigen (dann ist der Speicher voll, oder es sind keine Elemente gespeichert). Prinzip verstanden? Bsp.:

Speicher:
0000|0001|0002|0003|0004
1.El. 2.El. 3.El 4.El unbelegt

jetzt werden zwei Elemente gelesen (first in first out, also das 1. und 2. Element, die 3. und 4. Elemente sind jetzt die 1. und 2.)
->
0000|0001|0002|0003|0004
unb. unb. 1.El. 2.El. unbelegt

jetzt werden 2 Elemente hinzugefügt
->
0000|0001|0002|0003|0004
4. El. unb. 1.El. 2.El. 3.El.
Die Belegung fängt wieder am Anfang an.

 

[uli-tt]

OK da smit dem zu langen Quellcode sehe ich ein, daher habe ich den etwas gekürzt!

Das Wesentliche:
Ich habe einen Schleife und will dort Daten von einem Bus in einem Speicherbereich schreiben. Diese Daten will ich von dort wieder nehmen und mit einer weiteren Schleife ausgeben.

Die Daten sind vom Typ „unsigned char“ (hex) und ich dachte daran die Daten mit colloc, malloc und free zu verwalten, wie gesagt ich weiß nicht wie ich das umsetze, bin halt Anfänger! Es wird doch schon mal jemand einen FIFO geschrieben haben?


Uli

 

[Dudadida]

Hab selbst noch keinen FIFO Puffer benutzt und mir das nur aus den Haaren herbeigezogen, würde es halt so machen (oder ähnlich):

#define LAENGE 100

unsigned char* puffer = (unsigned char*)malloc(LAENGE);
unsigned char* anfang = puffer;
unsigned char* ende = puffer;
int menge = 0;

//Etwas reinschreiben (in dem Fall die Zahl 12, also irgendein byte):
*ende = 12;
menge++;

//Zeiger neu setzen, damit man nix überschreibt
//Das ++ vor dem ende in der if Anweisung macht das bereits, wenn 
//am Ende des Puffers, dann wird ende wieder auf den Anfang gesetzt
if (++ende >= (puffer+LAENGE)) ende = puffer;

///////////////////////////////////
//Etwas rauslesen, das erste geschriebene Element
unsigned char readbyte = *anfang;
menge--;

//Zeiger neu setzen
if (++anfang >= (puffer+LAENGE)) anfang = puffer;

Die Ausnahme ist, dass wenn anfang und ende auf die gleiche Adresse zeigen und menge != 0, dann ist der Speicher voll, wenn beide auf die gleiche Adresse zeigen und menge == 0, dann ist der Speicher leer.
Ach so, ich hab gerade keinen Compiler installiert und kann das nicht ausprobieren, kann sein dass (puffer+LAENGE) nen Fehler ergibt, in dem Fall puffer in nen int casten, also ((int)puffer + LAENGE) und die Zeigervariable mit der du vergleichst ebenfalls ((int)(++ende)).