Hallo Bin grad dabei das flash At45DB011 als Ringbuffer aufzubauen. Der uC LPC2129 kommuniziert über SPI mit dem Flash. Weiß jemand wie man den Ringbuffer aufbauen kann? Als FIFO?Das Reinschreiben ist irgendwie verständlicher, aber wie liest man denn aus dem Flash? Woher weiß man wo das Head und Tail sich befindet. Hätte mir da jemand einen Tipp wie man da am besten vorgeht? Hab bis jetzt um das Flash zu beschreiben den Befehl genommen der eine Struktur direkt in eine page schreibt. 512 pages sind im Flash vorhanden. Hätte mir dazu jemand einen Tipp wie man das am besten macht? grüße
Na, jeden Tag eine neue Frage? Immer noch Trockenübungen, oder hast du jetzt schon eine Hardware? Implementierungen von Ringpuffern in C gibt es wie Sand am Meer. Tante google weiß Bescheid... Oliver
Ja schon,aber die letzte Frage ist ja schon wieder eine Weile her. Haben ein testbord bekommen, aber da wird nur die i2c übertragung getestet. Du hast mir ja den code gegeben um daten in das flash zu schreiben. Schick ich dann einfach der Struktur den head und Tail Wert mit in den Flash? Aber wie wird das dann ausgewertet wo er dann steht? Muss doch irgendwo die Auswertung von Head und Tail machen?!
>Du hast mir ja den code gegeben um daten in das flash zu schreiben. >Schick ich dann einfach der Struktur den head und Tail Wert mit in den >Flash? Aber wie wird das dann ausgewertet wo er dann steht? Muss doch >irgendwo die Auswertung von Head und Tail machen?! Meine Güte. Werd dir mal drüber klar wie viele Bytes deine Struktur verbraucht. Wieviele Strukturen passen in eine Page? Passen mehrere Strukturen genau in eine Page? Dann ists einfach. Passen mehrere Strukturen nicht in eine Page dann am besten Verschnitt hinnehmen und Pageüberlauf vermeiden. Ist einfacher zu programmieren.
hab bis jetzt ca 15 messwerte je 2 byte in der Struktur. Dazu kommt noch die Echtzeit, die bestimmt auch noch bischen was brauch. Wäre es ungeschickt für eine page auch nur eine Struktur zu nehmen? Eine page hat 264 bytes. Dann wäre halt einiges verschenkt, aber ist bestimmt leichter zum schreiben.ODer was würdest du vorschlagen?
>hab bis jetzt ca 15 messwerte je 2 byte in der Struktur. Da hast du schon mal 30 Bytes. > Dazu kommt noch >die Echtzeit, die bestimmt auch noch bischen was brauch. Du solltest jetzt erst mal klären wieviele Bytes deine Uhrzeit braucht. >Wäre es ungeschickt für eine page auch nur eine Struktur zu nehmen? >Eine page hat 264 bytes. Dann wäre halt einiges verschenkt, aber ist >bestimmt leichter zum schreiben.ODer was würdest du vorschlagen? Eine Struktur pro Page ist ein zu großer Verschnitt. Also löse erstmal das Problem mit der Uhrzeit. Dann kann man weiter reden.
für die Uhrzeit werd ich aus dem CTIM0 Register die Sekunden, Minuten, Stunden, Wochentag, tag des Monats, Monat und das jahr herausziehn. Das wären dann nochmal jeweils 1 Byte, Also für die Komplette Zeit 8 Byte. Hab die Zeit auseinandergenommen, da ich ja soweiso nur ein byte nach dem anderen über die SPI Schnittstelle schicken kann. Also insgesamt wären das ja pro Strukt dann 38 Bytes. Was würdest du vorschlagen was besser wäre?
>Also insgesamt wären das ja pro Strukt dann 38 Bytes. Was würdest du >vorschlagen was besser wäre? 38 Bytes pro Struktur sind nicht günstig. 264/38 = 6.94 ein schlechter Wert. Man könnte jetzt Padding Bytes (unbenutze) einfügen. Bei 264/44 kommt man auf einen geraden Teiler von 6 Strukturen pro Page. Das wäre dann ein Verschnitt von 6 Bytes pro Struktur. Ist schon recht viel. Aber vieleicht kann man die Padding Bytes für spätere Erweiterungen nutzen ;) Denk mal drüber nach ob man die Uhrzeit nicht günstig zusammenpacken kann. Wenn du auf 33 Bytes kommst passen 8 Strukturen in eine Page.
Sollte man nicht jeden Datensatz noch ne fortlaufende Nummer geben, damit man schnell den Head findet, weil wenn man jedes mal die Head-Position (z.B. in Page 0) abspeichert, wird diese Page wohl ziemlich schnell die 10000 Schreibzugriffe abbekommen. Gruß Roland
>Sollte man nicht jeden Datensatz noch ne fortlaufende Nummer geben,
Die Uhrzeit sollte genügend aussagekräftig sein um rauszufinden
wo Anfang und Ende ist.
Hab folgende Maske erstellt um aus dem CTIME0 Reg die Sekunden zu bekommen: 0x003F für die Minuten: 0x3F00, Stunden 0x001F 0000 usw. NAchdem ich die Masken mit dem CTIME0 Reg verundet hab, dann ist ja bei allen Zeiteinheiten, außer bei den Jahren nirgendwo 1 byte voll belegt. Wäre es sinnvoll, einfach welche zusammenzuschieben, das man auf die 33 bytes kommt oder auffüllen, das man auf 44 bytes kommt? enn ich nur eine struktur pro page nehm, ists ja glaub leichter, wie aber macht man es wenn man mehrere strukturen in eine page schreiben will. das Head und Tail anhand der pages ist ja relativ verständlich,aber wie geht man vor wenn in den pages auch noch mehrere strukturen sind?
>das Head und Tail anhand der pages ist ja relativ verständlich,aber wie >geht man vor wenn in den pages auch noch mehrere strukturen sind? Eine Strukturzählschleife pro Page? Ich gebs auf :( Dir fehlt einfach ein bißchen Vorstellungskraft.
so hab ich das eigentlich nicht gemeint. hab es so gemeint das ich ja eine struktur hab in der die ganzen messwerte stehn. und davon werden ja dann mehrere strukturen in eine page geschreiben. also nur eine struktur. oder hast du gedacht ich meine es anderst?
Hast mir nicht noch einen kleinen Anhaltspunkt zum weiteren Vorgehen? Wie du das mit dem komprimieren, das auch genau 7 oder 8 strukuren in eine page passen, hab ich ja soweit verstanden. nur wie setzt man das programmtechnisch um?
Irgendwie hat's keinen Sinn. Lass es sein. Das wird nie was. Sorry.
Hi Ist das so schwer? Du hast 512 Pages. Jede Page kann n Structs enthalten. Damit bekommst du einen Adressraum von 512*n-1. Ein Struct mit der Adresse X ist in der Page X div 512 und befindet sich innerhalb der Page auf Adresse (X mod 512) * SizeOf(Struct). Fertig. MfG Spess
Das ich bei 512 pages 512 adressen hab ist mir klar, wie ich aber nochmal in den einzelnen pages die adressen für die einzelnen tructs bekomme ist mir immernoch ein rätsel. da ich sowas noch nie gemacht hab fällt mir das ganze schon bisschen schwerer. So wie du das bescheiben hast, so schreib ich ja hintereinander die pages voll. Was passiert wenn alle pages voll sind? Was du mit dev und mod meinst ist mir auch nicht ganz klar?
>Was passiert wenn alle pages voll sind? Dann musst du das Flash auslöten und ein neues einbauen. Das volle ist dann unbrauchbar. Nennt sich WROM: Write-Only Memory. Warum heisst der Ringpuffer wohl Ringpuffer? Oliver P.S. Ich wage ja gar nicht zu fragen, für was das eine Abschlussarbeit werden soll. P.P.S. Heute im Angebot in der Codesammlung, ganz oben: Beitrag "Konzept für einen Ringpuffer"
Hi
>Was du mit dev und mod meinst ist mir auch nicht ganz klar?
Dann hast du noch viel zu lernen. 'div' Ganzzahldivision; 'mod'
Modulooperation ( der Rest einer Ganzzahldivision). Der Sinn ist, das du
mit einer Adresse für eine Struct arbeiten kannst. Der Rest ist dann wie
ein normaler Ringpuffer. Du zählst die Adresse hoch. Wenn die höchste
Adresse erreicht ist wird bei Null wieder angefangen.
Als Beispiel:
512 Pages
4 Structs/Page
10 Bytes/Struct
Adressraum: 2048 (höchste Adresse: 2047)
Adresse: 1234
Page= 1234/4= 303
Da haben sich oben zwei Fehler eingeschlichen, Richtig: Page= X div n
und Pageadresse (X mod n) * SizeOf(Struct)
Structadresse(in Page): (1234 mod 4)*10=2*10=20
MfG Spess
ja weil wenn er voll ist, die neuen daten die alten daten überscheiben. Weiß eines nur nicht ob das Flash weiß wann er voll ist und dann selber von vorne wieder anfängt oder muss ich das dem sagen? das beispiel sieht ja schon heftig aus, bei mir muss das lange nicht so aussehn*g* Wie das mit dem Tail und Head bezwecken soll ist mir schon klar nur weiß ich nicht wie ich das auf die Aufgabenstellung anbringen kann. Ja da liegst richtig, ist eine Abschlussarbeit, aber es ist ja nicht erboten andere zu fragen wenn man keine Ahnung hat, oder was meinst du?
meinst du modulodivision, also immer duch 2 teilen? weil davon hab ich schonmal was gehört
Das muss ich mal mal genau anschaun, aber schonmal vielen dank für die ganzen tipps
Hi >meinst du modulodivision, also immer duch 2 teilen? weil davon hab ich >schonmal was gehört Nein 10 mod 3 = 1. Das ist der Rest Herr wirf Hirn vom Himmel. Sag mal, normalerweise kann doch nicht viel mehr verlangt werden, als ihr gelernt habt. Hast du die ganze Zeit gepennt? MfG Spess
die abschlussarbeit hat nichts mit dem zu tun was wir im unterricht machen, vielleicht zu 5%, abr nicht mehr. man muss sich alles selber aneignen oder es ist jemand schon angeboren. a
aber dann wäre doch (1234 mod 4)*10=2*10=20
rest 0,5 *10=.... ,oder?
Hi
>abr nicht mehr. man muss sich alles selber aneignen oder es ist jemand >schon
angeboren.
Nö. Musste mir das auch selbst aneignen. Und zwar in den 80-zigern ohne
Internet. Meine C-Kenntnisse habe ich hier nur aufgschnappt (noch nie in
C Programmiert). Aber irgendwelche Grungkenntnisse in Informatik (was
auch immer da gelehrt wird) solltest du mitbekommen haben.
MfG Spess
Ja einbisschen weiß ich ja auch.Aber das gebiet überrifft mein Wissen. wenn ich aber die pages alle komplett vollscheibe, dann benötige ich doch nicht die ganzen umrechnungen,oder? Also wenn ich eine Struktur a 44 Byte hab bekomm ich in eine page 6 Strukturen. Also insgesamt 3072 Einzeladressen. Wie sag ich aber dem Flash das er eine Struktur aus der bestimmten Adresse lesen soll? Wenn man reinschreibt, schreibt man dann einfach die Werte in eine page und da die pages ja sowieso komplett voll werden gibts da auch keine probleme,oder? Wie geht man dabei mit dem Head und dem Tail vor? Muss man dabei ständig die Werte aus dem flash lesen oder wie soll das funktionieren? Wäre so froh wenn mir da helfen könntest
Hi Lös dich doch mal von der Vorstellung alles mit einmal zu machen. Du machst einen Programmteil, der den Rinpuffer verwaltet. der arbeitet einfach mit Adressen. In deinem Fall 0..3071. Die Verwaltung von Head und Tail wird auch über diese Adressen vorgenommen. Also unabhängig von deiner Speicherstruktur. Den Funktionen für Schreiben und Lesen übergibst du Adresse und Struct. Erst diese Funktionen rechnen die Adresse in Page und Adresse innerhalb der Page um. Umrechnung siehe oben. MfG Spess
Ist es aber nicht so das man sagen kann das die erste Adresse 0 ist, die zweite 43 usw und die letzte 3071? Was mach ich denn dann noch mit dem mod und dev? Zu der Verwaltung des Ringbuffers gehört ja auch das mit dem Head und Tail,oder? Um aber den aktuellen stand aus dem Buffer zu erfahren muss ich doch vor jedem hineinschreiben erstmal rausbekommen wo mein Head steht oder lass ich den einfach immer um 1 hochzählen und wenn er einmal bei 3071 war läuft der Tail dem Head einfach hinterher? hab es bis jetzt erst so weit das ich die Messwerte alle in einer Struktur hab und Byteweise in das flash schicke aber nicht weiß wo die Daten genau liegen. Wie ist das denn mit dem Ringbuffer wenn mal die Spannung ausfällt. Funktioniert das dann immer noch das man den aktuellen Stand hat zwecks Head und Tail? Echt super nett deine Hilfe, danke
Hab im Netz was gefunden? Weisst du was die damit anfangen? Hab den
AT45Db011.
AT45_DEVTAB at45_devt[] = {
00269 {512, 264, 9, 0x3C, 0x0C}, /* AT45DB011B - 128kB */
00270 {1025, 264, 9, 0x3C, 0x14}, /* AT45DB021B - 256kB */
00271 {2048, 264, 9, 0x3C, 0x1C}, /* AT45DB041B - 512kB */
00272 {4096, 264, 9, 0x3C, 0x24}, /* AT45DB081B - 1MB */
00273 {4096, 528, 10, 0x3C, 0x2C}, /* AT45DB0161B - 2MB */
00274 {8192, 528, 10, 0x3C, 0x34}, /* AT45DB0321B - 4MB */
00275 {8192, 1056, 11, 0x38, 0x38}, /* AT45DB0642 - 8MB */
00276 {0, 0, 0, 0, 0} /* End of table */
Auf der Seite : http://www.ethernut.de/api/at45db_8c.html
ist unter anderem folgender opcode definiert den ich auch zum schreiben
benutze. Hoff mal das ich den richtigen gewählt hab.
#define DFCMD_BUF1_PROG 0x82 Versteht du wie die da vorgehen und ob
die auch eine Art FIFO dort machen?
Hi >hab es bis jetzt erst so weit das ich die Messwerte alle in einer >Struktur hab und Byteweise in das flash schicke aber nicht weiß wo die >Daten genau liegen. Verstehe ich nicht. Beim Speichern must du doch ein Page auswählen und die Speicheradresse innerhalb der Page angeben. Also noch mal. Deine Ringpufferverwaltung (Funktion) weiss nichts und braucht auch nichts von irgendwelchen Pages oder sonst was zu wissen. Die interessiert nur die logischen Adressen 0...3071. Damit ist es auch uninteressant ob du Structs, Bytes oder Bockwürste speicherst. >Um aber den aktuellen stand aus dem Buffer zu erfahren muss ich doch vor >jedem hineinschreiben erstmal rausbekommen wo mein Head steht oder lass >ich den einfach immer um 1 hochzählen und wenn er einmal bei 3071 war >läuft der Tail dem Head einfach hinterher? Einfach vor jedem Schreiben oder Lesen den entprechenden Zeiger eins weiterzählen. Wenn beim Schreiben dabei der Schreibzeiger gleich dem Lesezeiger wird ist der Puffer voll. Umgedreht ist der Speicher leer. Jedenfalls so ähnlich. Wenn Schreiben oder Lesen möglich ist übergibt die Pufferverwaltung die Daten und zugehörige logischer Adresse der eigentlichen Schreib-/Leseroutine. Die rechnen dann die Adresse in Page und Adresse in der Page Page um (mit div und mod). Du must dir das wie einen Treiber auf dem PC vorstellen. Wenn ein Progamm eine Datei abspeichert, dann ist es dem Programm völlig Wurst, wo die Daten auf der Festplatte legen. Es will nur beim Lesen genau die Datei wiederhaben. Du solltest dir dringend angewöhnen Dein Problem (Programm) in überschaubare und sinnvolle Bröckchen (Funktionen) zu zerlegen. MfG Spess
Hi
>Weisst du was die damit anfangen?
Nicht wirklich. Erstens habe noch nicht mit den Teilen gearbeitet und
zweitens beschränken sich meine C-Kenntnisse auf das was ich hier
aufgeschnappt habe. Wenn du das gleiche in Assembler besorgst kann ich
dir besser weiterhelfen.
Habs nur mal kurz überflogen.
Die Parameter der Tabelle berchreiben die Parameter der einzelnen ROMs.
Im Programm werden die passenden Parameter in eine Struct geladen. Dem
Namen nach wird das als Art DCB (Devce Control Block) benutzt. Habe da
auch Funktionen zu Lesen und Schreiben gesehen. Läuft über einen (Ram-)
Puffer.
Wirst du wahrscheinich auch machen müssen, da mir dunkel in Erinnerung
ist, das Pages nur komplett gelesen oder gespeichert werden können. Und
eine Page muss vor den Schreiben gelöscht werden.
MfG Spess
>Wirst du wahrscheinich auch machen müssen, da mir dunkel in Erinnerung >ist, das Pages nur komplett gelesen oder gespeichert werden können. Und >eine Page muss vor den Schreiben gelöscht werden. wenn das so ist, dann ist ja erstens mal mein opcode falsch und die ganzen routine um ins flash zu schreiben. Wird das dann so sein das man den ganzen buffer füllt (264 bytes) und wenn der buffer voll ist wird der inhalt des buffers in die beliebe page geschreiben? Dann braucht man doch bestimmt einen opcode solange die pages noch leer sind und wenn alle pages einmal beschreiben sind, dann muss man vor dem beschreiben erstmal löschen und einen anderen opcode nehmen,oder? Dann müsste man den opcode buffer write (0x84) und um dann die daten aus dem buffer in die pages zu schreiben den opcode buffer to main memory page program with built in erase (0x83).Oder was meinst du? Beim lesen muss man ja nicht unbedingt über den buffer gehn, dann liest man halt mehrere strukturen heraus
Hi Zum Schreiben und Lesen sieh dir mal diese AppNote auf der Atmel Webseite an: *AVR335: Digital Sound Recorder with AVR and DataFlash* Da ist auch Software dabei. MfG Spess
Meinst du mit Software das da en code beispiel dabei ist? Bin grad auf nem Datenblatt. Das was ich im davor geschrieben hab, die zwei unterschiedlichen opcodes, was glaubst ob das gehen würde? Die Bilder die da dabei sind sind genauso, wie ich oben geschreiben hab, also erst 0x84 dann 0x83. Wäre es eigentlich nicht geschickter wenn man beim schreiben schon alles in den buffer schreibt und dann komplett in eine page, aber beim auslesen einfach nur eine komplete page nimmt? das wäre doch dann auch leichter mit der Adressierung, da man ja dann nur die 512 pages anspricht, oder was meinst du?
Hi Habe mal einen kurzen Blick in das Datenblatt geworfen. Wenn ich das in Relation zu deinem Wissen und Fähigkeiten setze, würde ich an deiner Stelle mindesten 2 Jahre für das Projekt ansetzen (optimistische Schätzung). Tut mir leid, soviel Zeit habe ich leider nicht. Vielleicht solltest du erstmal mit nem kleinen seriellen EEPROM anfangen. MfG Spess
so hab ich das eigentlich auch nicht gemeint. brauch halt nur immer einen kleinen anstoß das ich weiß wie ich am besten weiter vorgehe. Das was ich mach muss ja auch nicht 100% fehlerfrei sein. Welches datenblatt meinst du denn? Grob gesagt kann ich es doch so machen, dass ich erst den opcode nehme um in den buffer zu schreiben, dann 6 strukturen hineinschreib und dann komlett in die nächste frei page schicke. Auslesen einfach nur eine komplette page. Oder liege ich damit auf nem ganz falschen weg?
Was is jetzt eigentlich dein Problem? Du redest hier von Flash.. Uhrzeit.. Speicherverwaltung.. Ringpuffer.. das sind alles verschiedene Dinge! Klar in deinem Projekt gehören sie zusammen, aber die Uhrzeit ist das WAS gespeichert wird.. der Flash ist WO gespeichert werden soll und der Ringpuffer ist das WIE... Wenn du hier alles durcheinander sch(m)eisst kommst du nie auf einen grünen Zweig. Ein Ringpuffer is wohl das einfachste... programmier mal einen auf dem PC in C! Ich hoffe du hast einen C-Compiler... guggst du hier:
1 | #define MAX_COUNT 10
|
2 | |
3 | typedef enum { |
4 | false = 0, |
5 | true = 1 |
6 | } BOOL; |
7 | |
8 | BOOL buffer_empty = true; |
9 | |
10 | unsigned char buffer[MAX_COUNT]; /* Hier passen 10 Werte rein */ |
11 | |
12 | unsigned char buffer_read = 0; |
13 | unsigned char buffer_write = 0; |
14 | |
15 | void buffer_write (unsigned char val){ |
16 | buffer[buffer_write] = val; |
17 | |
18 | buffer_write += 1; |
19 | buffer_write = buffer_write % MAX_COUNT; /* Oh schau mo.. MODULO */ |
20 | |
21 | buffer_empty = false; /* Buffer is nimmer leer */ |
22 | }
|
23 | |
24 | unsigned char buffer_read(unsigned char & ret_val){ |
25 | |
26 | BOOL ret = false; |
27 | |
28 | if (buffer_empty == false){ |
29 | ret_val = buffer[buffer_read]; |
30 | buffer_read += 1; |
31 | buffer_read = buffer_read % MAX_COUNT; |
32 | |
33 | ret = true; |
34 | |
35 | if (buffer_read == buffer_write) /* Leser hat den Schreiber eingeholt */ |
36 | buffer_empty = true; /* nix meh do */ |
37 | }
|
38 | else
|
39 | {
|
40 | ret = false; |
41 | }
|
42 | |
43 | return ret; |
44 | }
|
Ja ich weiß, bei mir ist es das Problem das ich nicht weiß wo ich
anfangen soll. Bin halt echt ein richtiger anfänger was das c
programmieren angeht.
>Du redest hier von Flash.. Uhrzeit.. Speicherverwaltung.. Ringpuffer
Auf welcher Baustelle würdest du denn als erstes anfangen?
Erstmal das mit der uhrzeit hinbekommen,oder?
Die routinen zum reinschreiben hab ich schon fast gehabt, jetzt aber
muss ich alles wieder verschmeißen weil es doch nicht richtig war.
Anfängerpech halt
weisst du denn wo es evtl schon fast fertige example codes gibt,die
einbisschen meine Probleme schmälern könnten
was macht denn die folgende anweisung:buffer_read = buffer_read % MAX_COUNT;? Also das % mein ich. Könnte ich die routinen auch für mein Problem anwenden? Also das noch an die SPI Übertragung und Flash/Buffer anpassen?
>was macht denn die folgende anweisung:buffer_read = buffer_read % >MAX_COUNT;? >Also das % mein ich. Das "%" ist das berühmte MODULO ;-) Die Ganzzahl Division. 10 % 3 = 3,3333333... -> 3 * 3 = 9 --> 10 - 9 = 1 !!! Der Ganzzahl Rest ist also 1. So funktioniert Modulo. Der Sinn ist hier, dass der Buffer 10 Werte fassen kann. Aber in ein Array darfst du ja dann nur die Elemente [0] - [9] adressieren. wenn du nun deinen Counter hochzählst.. 0,1,2,3,4,5,6,7,8,9,10... dann würde es bei 10 krachen, aber du willst ja einen Ring! Also bei 10 sollte er auf 0 springen! Wenn du den Counter jetzt immer mit %10 (modulo 10) verarbeitest, sieht die Folge dann so aus: 0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0... usw. Du könntest auch schreiben:
1 | counter = counter + 1; |
2 | if (counter == 10) |
3 | counter = 0; |
PS: Das COde Stück von mir is mit vorsicht zu genießen!! Der Lesezeiger würde nicht merken, wenn er einmal überrundet wurde... das muss man anders lösen, aber auf die schnelle is es mir net eingefallen ;-)
hey danke, echt voll super verständlich geschrieben auch für einen Anfänger*g* Was einst mit dem Lesezeiger und der Überrundung?
Morgen, Könntest du mir evtl sagen wie du am besten vorgehen würdest, welchen Schritt du als erstes machen und wie dann weiter machen würdest. Nur das ich mal einen kleinen anhaltspunkt hab. grüße
Wenn ich dein Beispiel um in den buffer zu schreiben übernehmen würd,
könntest du mir evtl zeigen wie man das mit einem Zeiger macht, das ich
immer den Stand in dem buffer erstmal sehen kann, wieviel schon drinn
steht? Für eine Page wird es ja bestimmt genauso gemacht, mit paar
änderungen.
Werd jetzt erstmal die 6 Strukturen in den buffer schreiben bis er voll
ist und dann in eine page.
Würde es wie dein Beispiel schreiben
#define MAX_COUNT 6
BOOL buffer_empty = true;
unsigned char buffer[MAX_COUNT];
unsigned char buffer_write = 0;
void buffer_write (unsigned char val){
buffer[buffer_write] = val;
buffer_write += 1;
buffer_write = buffer_write % MAX_COUNT; /* Oh schau mo.. MODULO */
buffer_empty = false; /* Buffer is nimmer leer */
}
Wie aber übergeb ich dann die Adresse an die funktion die in den buffer
schreibt?Wenn ich einen Spgausfallhab, dann geht doch der aktuelle Stand
verloren,oder woher weiß ich dann was schon drinn ist?
Das mit dene Zeiger ist mir nicht so ganz klar.
Wäre nett wenn mir weiterhelfen könntest
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.