Hallo,
bin ziemlicher uC Neuling und hab folgendes Problem:
Muss in das Flash eine Struktur einlesen mit 15*2 short Werten.Das soll
ung 500mal in einer gewissen zeit geschehn. Wie und wo mach ich das, das
z.B. nach einem read Befehl oder nach einem Neustart das Flash genau
weiß in welche Page geschreiben werden soll?
Schreibt man bei dem Flash gleich auf die einzelnen pages oder erst in
einen Block?Was ist der genaue Unterschied?
Write Beispiel
SPI_Write(address++, data.cycle_count & 0xff);
SPI_Write(address++, data.cycle_count >> 8);
read Beispiel
data.battery_mode = SPI_Read(address++);
data.battery_mode |= SPI_Read(address++) << 8;
Wo müsste ich denn da was abändern das ich auf die einzelnen pages
zugreifen kann?Wie lege ich denn die startpage fest?
grüße
>Das soll ung 500mal in einer gewissen zeit geschehn.
...
>Wie und wo mach ich das,
Gegenfrage: WARUM machst du das?
AVR-Flash ist auf 10.000 Schreibzyklen Zyklen garantiert. Selbst wenn es
10 mal so lange hält, ist kannst du deine Anwendung nur 200 mal laufen
lassen. Reicht das?
Oliver
Was meinst mit Überzählige Wörter?
Warum ich das mache?was?
Der Flash soll in einer Art ring aufgebaut werden. Ist er voll wird das
älteste Überschreiben.
Wie meinst das mit den Schreibzyklen?
Auf dem datenblatt von dem Flash stehen die ganzen Commands wie man die
einzelnen pages beschreiben sollte. Weiß nicht besonders viel mit denen
anzufangen.Du etwa?
Steff wrote:
> Wie meinst das mit den Schreibzyklen?> Auf dem datenblatt von dem Flash
Genau um dieses Datenblatt geht es. In diesem Datenblatt steht mit hoher
Wahrscheinlichkeit drin, wie oft der Flash überschrieben werden kann,
bevor er kaputt geht.
Was Du vorhast, klingt nach einem Programm, dass ständig ins Flash
schreibt. Wenn das so stimmt, wird Dein Flash schon nach kurzer Zeit das
zeitliche segnen. Es wäre dann besser, Du würdest ein RAM benutzen.
Falls wir Dich falsch verstanden haben, bitt nochmal genau schildern,
was Du eigentlich vor hast.
Gruss
Andreas
Auf dem datenblatt steht irgendwie noch drauf das ein SRAM vorhanden ist
mit 264bytes.Was mach ich damit?
Es soll nicht ständig hineingeschreiben werden nur bei bestimmten zyklen
durch den Timer. Bin in dem ganzen Gebiet noch voll der
Anfänger(Ausbildung).
Soll/Muss einen flash nehmen, wurde mir so vorgegeben. Fragt mich bitte
nicht wieso.
Muss man beim beschreiben und lesen über den buffer gehn oder kann man
die pages direkt addressieren? wie würde das denn mit den obigen read
und write beispielen aussehn?
Wäre so froh wenn du mir weiterhelfen könntest
>Schreibt man bei dem Flash gleich auf die einzelnen pages oder erst in>einen Block?
Auf pages.
>Was ist der genaue Unterschied?
Ein Block besteht aus mehreren pages. Die einzige Operation auf Blöcken
ist löschen, brauchst du vermutlich nicht.
>Auf dem datenblatt steht irgendwie noch drauf das ein SRAM vorhanden ist>mit 264bytes.Was mach ich damit?
Im Flash lassen sich nur ganze pages am Stück schreiben, im SRAM dagegen
kannst du jedes byte einzeln schreiben. Wenn du also im Flash nur ein
Byte ändern willst, holst du zunächst die ganze page vom Flash ins SRAM,
änderst dort dein Byte, und schreibst dann die ganze page wieder zurück.
Dafür gibt es fertige Befehre, z.B. AUTO PAGE REWRITE.
>Muss man beim beschreiben und lesen über den buffer gehn oder kann man>die pages direkt addressieren?
Beim schreiben ja, beim lesen nein.
>wie würde das denn mit den obigen read>und write beispielen aussehn?
Keine Ahnung, ob das damit geht. Als Beispiel mal MAIN MEMORY PAGE READ:
"To start a page read, the 8-bit opcode, 52H, is followed by 24
address bits and 32 don’t care bits."
Also schaltest du als erstes mal !CS auf low, damit das Flash weiß, daß
es angesprochen wird, und schickst dann zunächst 8 Byte, bestehend aus
dem Opcode 0x52 für das Kommande MAIN MEMORY PAGE READ, 24 Bits als
Startadresse (bestehend aus page-Nummer und Startbyte in dieser page),
ab der gelesen werden soll, und 32 bits, bei denen egal ist, was drin
steht, die müssen nur da sein. Nach diesen insgesamt 8 Bytes kommen dann
die angeforderten Daten aus dem Flash zurück, ein Bit per Clock, und
zwar so lange, wie CL low ist und SCL taktet. Es liegt dann an dir, wie
viele Bits du lesen möchtest.
Oliver
Steff wrote:
> Auf dem datenblatt steht irgendwie noch drauf das ein SRAM vorhanden ist> mit 264bytes.Was mach ich damit?
Der SRAM ist Dein Fenster in den Flash. Du kannst Daten dort
hineinschreiben und dem Chip dann sagen, dass er diese Daten vom SRAM in
den Flash schreiben soll. Oder Du sagst dem Chip, er soll Daten vom
Flash in den SRAM kopieren. Von dort kannst Du sie dann auslesen.
> Muss man beim beschreiben und lesen über den buffer gehn oder kann man> die pages direkt addressieren? wie würde das denn mit den obigen read> und write beispielen aussehn?
Schau Dir die Seite 10 des Datenblattes an. Da kannst Du sehen, dass
Schreibbefehle immer über das SRAM laufen. Dabei gibt es zwei Methoden:
Entweder, Du "sammelst" Daten im SRAM mit dem "Buffer Write" Befehl
solange, bis der Buffer voll ist. Dann schreibst Du alles ins Flash mit
dem Befehl "Buffer to Main Memory Page Program".
Oder, wenn Du eine komplette Page mit Daten hast, schreibst Du diese in
einem Rutsch mit dem Befehl "Main Memory Page Program Through Buffer".
Jetzt schau Dir Seite 11 des Datenblattes an. Da kannst Du sehen, wie
das Lesen funktioniert. Du kannst entweder Daten vom Flash in den Buffer
laden, oder direkt auslesen.
Das Laden von Daten aus dem Flash in den Buffer macht z.B. dann Sinn,
wenn Du ein einzelnes Byte in einer Page ändern willst. Dazu liest Du
die Page in den Buffer, änderst das Byte mit dem Befehl "Buffer Write"
und schreibst dann die komplette Page zurück ins Flash mit dem Befehl
"Buffer to Main Memory Page Program".
Gruss
Andreas
danke, jetzt wird es schon verständlicher.
In meinem fall ist es ja so das alle 15 messwerte in der Struktur
jeweils 2 byte groß sind. Die Struktur soll komplett in das flash
geschrieben werden.
Was glaubst du wie das dann in der funktion, von der ich schon
dummerweis gedacht hab das se funktioniert, aussieht?
Kann mir darunter irgendwie nicht so arg viel vorstellen
void writeSPIBlock(int* currIdx, SPIDataBlock data) //currIdx=zeigt
aktuellen index an
{
if (currIdx > MAX_NO_SPIDATA)
{
*currIdx = 0
}
int address = SPI_START_ADR + currIdx sizeof(struct SPIDataBlock);
// store battery mode
SPI_Write(address++, data.battery_mode & 0xff);
SPI_Write(address++, data.battery_mode >> 8);
.
für die restlichen 14 messwerte dann das gleiche.
*currIdx++;
kannst du mir mal zeigen wie du das machen würdest?
Muss ich nicht die daten Byteweise ins flash schreiben?
wenn ich das komplette strukt direkt in die page schreib, könnte man
dann nachträglich die page noch beschreiben oder muss man bei diesem
vorgang dann die daten aus der page wieder ins SRam holen und dann das
struct zu den vorhandenen daten schreiben?
Steff wrote:
> muss man bei diesem> vorgang dann die daten aus der page wieder ins SRam holen und dann das> struct zu den vorhandenen daten schreiben?
Ja.
>oliver wrote:> Also schaltest du als erstes mal !CS auf low, damit das Flash weiß, daß>es angesprochen wird, und schickst dann zunächst 8 Byte, bestehend aus>dem Opcode 0x52 für das Kommande MAIN MEMORY PAGE READ, 24 Bits als>Startadresse (bestehend aus page-Nummer und Startbyte in dieser page),>ab der gelesen werden soll, und 32 bits, bei denen egal ist, was drin>steht, die müssen nur da sein. Nach diesen insgesamt 8 Bytes kommen dann>die angeforderten Daten aus dem Flash zurück, ein Bit per Clock, und>zwar so lange, wie CL low ist und SCL taktet. Es liegt dann an dir, wie>viele Bits du lesen möchtest.
Die ganzen Dinge die du hier beschrieben hast müsste die ich dann eher
hier ändern:
void SPI_Write(unsigned int Address, unsigned char Data)
{
Address = Address << 2; // RW bit is set to zero by shifting
the bit
// pattern to left by 2
Address |= 0x02; // Set write bit
SPI_PORT = SPI_PORT & (~SPI_CSB); // Set CSB to zero
S0SPDR = Address; // Write command to SPI bus
while(!(S0SPSR & (SPI_SPIF))); // Wait until data has been sent
S0SPDR = Data; // Write data to SPI bus
while(!(S0SPSR & (SPI_SPIF))); // Wait until data has been sent
SPI_PORT = SPI_PORT | SPI_CSB; // Set CSB to one
return;
}
Wie verknüpf ich nur das in vorhanden Quellcode?
Muss man das überhaupt so machen wie in der folgenden funktin zum
schreiben?schick ja erst das high dann das low byte
SPI_Write(address++, data.temperature & 0xff);
SPI_Write(address++, data.temperature >> 8);
>Wie verknüpf ich nur das in vorhanden Quellcode?
Gar nicht. Die SPI-Routine funktioniert nicht zu deinem Flash.
Anscheinend ist die für ein EEPROM o.ä., welches byteweise ausgelesen
werden kann.
Was du brauchst, müsste ungefähr so aussehen (ungetestet, ins unreine):
1
intschreibeDatenInsFlasch(uint16_tpage,// nur neun bit davon sind gültig
2
uint16_tstartbyte,// nur neun bit davon sind gültig
3
int16_tdaten[15])
4
{
5
uint8_topcode=0x82;// MAIN MEMORY PAGE PROGRAM;
6
uint8_tadressfeld[3];
7
8
/*
9
An 8-bit opcode
10
of 82H is followed by the six reserved bits and 18 address
11
bits. The nine most significant address bits (PA8-PA0)
12
select the page in the main memory where data is to be
13
written, and the next nine address bits (BFA8-BFA0) select
14
the first byte in the buffer to be written.
15
*/
16
17
page&=0x1ff;// es dürfen nur 9 bit sein
18
startbyte&=0x1ff;// es dürfen nur 9 bit sein
19
20
adressfeld[0]=(uint8_t)(page>>6);// 6 reserved bits und die zwei MSB's der 9 pagebits
21
adressfeld[1]=((uint8_t)(page)<<1)|// die restlichen 7 Bit der pagenummer
22
(uint8_t)(startbyte>>8);// hinten drann das MSB des startbytes
23
adressfeld[2]=(uint8_t)(startbyte&0xff);// die restlichen 8 Bit des startbytes
24
25
// Los gehts
26
SPI_PORT~=(1<<SPI_CSB);// Set CSB to zero
27
28
// opcode ausgeben
29
S0SPDR=opcode;// Write command to SPI bus
30
while(!(S0SPSR&(SPI_SPIF)))
31
;// Wait until data has been sent
32
33
// pageadresse und startbyte ausgeben
34
for(uint8_ti=0;i<3;i++)
35
{
36
S0SPDR=adressfeld;// Write data to SPI bus
37
while(!(S0SPSR&(SPI_SPIF)))
38
;// Wait until data has been sent
39
}
40
// Daten ausgeben
41
for(uint8_ti=0;i<15;i++)
42
{
43
S0SPDR=(uint8_t)(daten[i]>>8);// Write data high byte to SPI bus
44
while(!(S0SPSR&(SPI_SPIF)))
45
;// Wait until data has been sent
46
47
S0SPDR=(uint8_t)(daten[i]&0xff);// Write data low byte to SPI bus
48
while(!(S0SPSR&(SPI_SPIF)))
49
;// Wait until data has been sent
50
}
51
52
SPI_PORT|=SPI_CSB;// Set CSB to one
53
}
Die entsprechende Lesefunktion kriegst du sicher selber hin.
Oliver
vielen vielen Dank. Echt super nett von Dir. Nur eine frage hätte ich
noch. War ja klar*g*
uint8_t adressfeld[3];
Was passiert denn in den folgenden Zeilen?
page &= 0x1ff; // es dürfen nur 9 bit sein
startbyte &= 0x1ff; // es dürfen nur 9 bit sein
adressfeld[0] = (uint8_t) (page >> 6); // 6 reserved bits und
die zwei MSB's der 9
pagebits
adressfeld[1] = ((uint8_t) (page) << 1) | // die restlichen 7 Bit
der pagenummer
(uint8_t)(startbyte >> 8); // hinten drann das MSB des startbytes
adressfeld[2] = (uint8_t) (startbyte & 0xff); // die restlichen 8 Bit
des startbytes
Was sagt denn zum beispiel folgende zeile aus?
adressfeld[0] = (uint8_t) (page >> 6);
Wieso steht denn das uint8_t in klammern? (uint8_t) (page >> 6); ?
Muss man nicht irgendeinen Zähler mit einem Zeiger mitgeben,oder
benötigt man das bei deiner Lösung nicht mehr unbedingt?
Muss ja eine Struktur komplett ins Flash schreiben(ca 15*2 byte). Müsste
man dann die schreibfunktion 15mal aufrufen?
Sorry für die sehr vielen anfängerfragen.
grüße
könnte ja um das SRAM voll zu bekommen ca 15mal oder so komplatt alles
reinschreiben. Ist es dann so besser wie du es gemacht hast, also direkt
ins flash schreiben oder ist es besser davor erst das SRAM vollschreiben
und dann ins flash schreiben?
>Ist es dann so besser wie du es gemacht hast, also direkt>ins flash schreiben oder ist es besser davor erst das SRAM vollschreiben>und dann ins flash schreiben?
Direkt ins Flash schreiben geht nicht. Ich habe den Befehl "MAIN MEMORY
PAGE PROGRAM" benutzt, bei dem zunächst die Daten ins SRAM geschrieben
werden. Am Ende der Kommunikation kopiert der Befehl dann von alleine
das SRAM ins Flash.
Mein Code ist nur ein Beispiel. Dabei bin ich davon ausgegangen, daß du
immer nur einen Satz Daten im Flash halten willst. Wenn die alten Daten
auch noch erhalten bleiben sollen, ist die Abfolge komplizierter. Das
steht aber im Datenblatt. Auch wenn das in Englisch ist, da musst du
durch. Datenblätter sind immer in Englisch. Das Datenblatt verweist auch
noch auf die Application Note AN-4. Besorg dir die, da steht bestimmt
auch noch Beachtenswertes drin. Das Flash muß z.B. alle 10.000
Schreib-/Lesezyklen "rewritten" werden.
>Was passiert denn in den folgenden Zeilen?
1
page&=0x1ff;// es dürfen nur 9 bit sein
2
startbyte&=0x1ff;// es dürfen nur 9 bit sein
Die oberen 7 bit werden auf Null gesetzt. Nur als Vorsichtsmaßnahme,
falls da jemand ungültige Werte einträgt. Kann man auch weglassen, bei
ungültigen Werten schreibt die Funktion eh irgenwo ungewollt ins Flash.
1
adressfeld[0]=(uint8_t)(page>>6);// 6 reserved bits und
2
// die zwei MSB's der 9
3
pagebits
4
adressfeld[1]=((uint8_t)(page)<<1)|// die restlichen 7 Bit
5
// der pagenummer
6
(uint8_t)(startbyte>>8);// hinten drann das MSB des startbytes
7
adressfeld[2]=(uint8_t)(startbyte&0xff);// die restlichen 8 Bit
8
desstartbytes
>Was sagt denn zum beispiel folgende zeile aus?>adressfeld[0] = (uint8_t) (page >> 6);>Wieso steht denn das uint8_t in klammern? (uint8_t) (page >> 6); ?
Die in C verfügbaren Datentypen sind entweder 8, 16 oder 32 Bit breit.
Das Flash erwartet die Adresse in 24 Bit: 6 Bit leer, 9 Bit Pageadresse
und 9 Bit Startadresse. Da braucht es halt etwas Bitschieberei, um 6+2*9
Bit in 3*8 Bit umzukopieren. Näheres über die Syntax steht in jedem
C-Buch.
Oliver
jetzt wird alles schon etwas einleuchtender.
Weisst du ob mit SPI_PORT die Pinnummer vom uC gemeint ist? Was könnte
dann das SPI_CSB sein?
Das mit den 8,16 und 32 Bit war mit schon klar. Bei mir ist es nur das
Problem wegen der Schreibweise. Woher weiß das "Programm" das uint8_t
eine 8Bit integer Zahl ist? Ist das schon irgendwas vordefiniertes?
Hast du das uint8_t einfach so selber festgelegt oder woher kommt das?
Hab ja eine Struktur(ca 30Byte) zum einlesen. Wenn alle Daten, die in
einer Gewissen zeit, gespeichert werden sollen, muss man dann nicht
einfach nur die Startadresse um die Größe der Struktur hochzählen?
Bei der Übergabe der Daten in dieser Funktion: int
schreibeDatenInsFlasch(uint16_t page, // nur neun bit davon sind gültig
uint16_t startbyte, // nur neun bit davon sind gültig
int16_t daten[15])
Für was wird denn hier das Feld mit 15 angegeben? Wenn ich eine
komplette Struktur mit dem Namen data übergeben will schreibt man dann
nicht einfach nur data.
Das wird dioch alles sehr kompliziert, weil auch noch ein zeitstempel
mit hinein muss.
>Weisst du ob mit SPI_PORT die Pinnummer vom uC gemeint ist? Was könnte>dann das SPI_CSB sein?
SPI_PORT wird der Port sein, zu dem der Pin gehört, der mit CS des Flash
verbunden ist. SPI_CSB ist die Pinnummer. Vermutlich ist das alles für
eine AVR geschrieben, und was da Ports und Pins sind, sollte man für
solch eine Projekt schon wissen.
>Woher weiß das "Programm" das uint8_t eine 8Bit integer Zahl ist?
Das sind Typen aus <stdint.h>. Die verwende ich halt immer.
>Für was wird denn hier das Feld mit 15 angegeben?
Irgendwas musste ich ja dahin schreiben. Nachdem du was von 15 Werten
geschrieben hast, hab ich das halt so gemacht. Das musst du
selbstverständlich an deine tatsächliche Datenstruktur anpassen.
>Das wird doch alles sehr kompliziert, weil auch noch ein zeitstempel>mit hinein muss.
Wichtig ist, daß du systematisch an die Aufgabe herangehst, auch wenn
dir im Moment noch nicht ganz klar ist, wie im Detail das alles
funktioniert.
Also:
1.) Was soll das Programm genau erfüllen? (Ganz wichtig !!!)
Danach kommt:
Was brauchst du alles, um 1.) zu realisieren.
Wie sieht eine grobe Programmstruktur dazu aus?
Bis hin zu:
Welche Daten sollen geschrieben werden?
Wie oft sollen die Daten geschrieben werden, oder nach welchem Ereignis?
Wie genau ist das mit dem Ring gemeint?
Wie sollen die Daten wieder gelesen werden?
usw.
>Bin in dem ganzen Gebiet noch voll der>Anfänger(Ausbildung).>Soll/Muss einen flash nehmen, wurde mir so vorgegeben. Fragt mich bitte>nicht wieso.
Etwas Hilfe sollte es doch auch von deinen Ausbildern geben. Ansonsten
ist die Aufgabenstellung für jemanden ganz ohne Vorkenntnisse viel zu
kompliziert.
Oliver
Das ich aber die ganze Struktur komplett in das Flash schreib geht also
auch,oder?
oder muss man dann die einzelnen werte aus der stuktur holen(jeweils 2
byte) und dann alle extra schreiben?
Was könnte man denn dann anstatt des types uint8_t schreiben? Könnte man
das nicht auch weglassen, an der ´Funktion ändert es ja nichts,oder?
wird in der nachfolgenden Zeile page um 6bit nach links geschoben und
dann durch (uint8_t) eine 8bit zahl?
adressfeld[0] = (uint8_t) (page >> 6);
Könnte man eigentlich anstatt von den ganzen opcodes z.B.: uint8_t
opcode = 0x82 auch für alle opcodes defines schreiben,also
#define PAGE_THROUGH_BUFFER 0x0082 ?
Das mit dem ring ist so viel ich weiß so gemeint, das wenn das Flash
komplett voll ist das flash einfach wieder von neuem mit neuen Daten
beschrieben werden soll.
Nach welchem die Ereihnis die Daten geschreiben werden sollen, spielt
grad bei diesem problem nicht so sehr eine Rolle,oder? Das stellt man
bei der Initialisierung ein glaub
SPI_CSB ist die Pinnummer: Nehm ich Nummer die auf dem datenblatt steht,
also hier die 4?
SPI_Port wäre ja dann p1_24: wie weiß ich denn dem uC den Port P1_24 als
den gewünschten Ausgang(CSFlash) zu. Bei den Ports bis P0_31 ists mit
klar. weiß es nur nicht genau bei den einer ports
ja glaub auch das es bisschen zu heftig ist für mich, muss es aber
unbedingt hinbekommen
>ja glaub auch das es bisschen zu heftig ist für mich
So ist es. Du solltest dir zunächst klar machen, was genau die Aufgabe
ist, welche Hardware du nutzen sollst, was du darüber weißt (und was
nicht), und was du dafür benötigst. Mit den Fragen, die du hier stellst,
bist du soweit von der Lösung weg wie die Erde von Alpha Centauri.
Oliver
Morgen,
ja das weiß ich auch.hab nur das Problem das ich das hinbekommen muss,
egal wie.So wie du oben das Beispiel geschreiben hast, so könnte ich ja
schonmal die write funktion übernehmen,oder?das problem da wäre halt,
das ich nur immer ein Wert in das flash schreiben könnte, aber ich halt
eigentlich mehrere Daten ins flash schreiben muss.
müsste ich dazu nicht einfach die Startadresse einfach immer um die
Größe von der Struktur, die ich ins Flash schreiben muss, erhöhen?
Würd das so gehen?
müsste man dazu einfach die einzelnen daten von der stuktur(je 2byte)
einfach hintereinander übergeben und ins flash schreiben, dann die
Startadresse um sizeof(struct) ehöhen und dann wieder jeweils die
einzelnen daten des strukt wieder ins flash schreiben, oder was müsste
man da noch beachten?
Wäre dir so dankbar wenn du mir noch ein bischen helfen könntest.Jeder
fängt ja mal klein an
>das problem da wäre halt, das ich nur immer ein Wert in das flash schreiben >könnte, aber ich halt eigentlich mehrere Daten ins flash schreiben muss.
So ist das halt. Solange du nicht mal weisst, auf welcher Hardware du da
rumspielen sollst, kommst du nicht weiter. Wenn du das rausgefunden
hast, nimm dir das Datenblatt des Controllers, und versuch zu verstehen,
was ein Port ist, wie das SPI-Interface funktioniert, usw. Dann finde
raus, wie das Flash und der Controller verschaltet sind.
Ohne solche Basics geht es nicht.
Oliver
Die Initialisierung von dem SPI hab ich ja schon vorgenommen.Welche
Hardware ich nehm weiß ich ja auch.
Die Routine die du oben geschreiben hast könnte ich ja nehmen um die
Daten ins Flash zu schreiben?Wenn ich aber den befehl von dir oben nehme
MAIN MEMORY PAGE PROGRAM dann werden ja die daten ins SRAM geschrieben
bis er voll ist und dann ins flash. langts da nicht einfach die page um
1 hochzuzählen?Also wen ich danach eine komplette page auslesen will,
dann wird dann einfach die reingeschriebene page öffters?!
Hätte noch eine Frage an dich zu dem code von dir
page &= 0x1ff; // es dürfen nur 9 bit sein
startbyte &= 0x1ff; // es dürfen nur 9 bit sein
adressfeld[0] = (uint8_t) (page >> 6); // 6 reserved bits und die
zwei MSB's der 9 pagebits
adressfeld[1] = ((uint8_t) (page) << 1) | // die restlichen 7 Bit
der pagenummer
(uint8_t)(startbyte >> 8); // hinten drann das MSB des
startbytes
adressfeld[2] = (uint8_t) (startbyte & 0xff); // die restlichen 8 Bit
des startbytes
das uint8_t mach ich ja um eine 8bit Zahl zu bekommen. wird es in den
anweseiungen erst geschoben und dann die 8bit zahl daraus gemacht oder
danach?
Beim links schieben ist es ja egal. Wird beim rechts schieben erst
generell geschoben und dann zur 8bit zahl gemacht oder ist das nur so
weil du oben auch anderst ausgeklammert hast?
Hallo,
bins mal wieder.
Weiß jemand wie man in den flash einen Zeitstempel mit hineingeben kann
und wie das aussieht?Wie geh ich da am besten vor?
um Daten aus dem Flash zu lesen geb ich einfach einen zeiger mit,oder?
grüße
Thread beobachten
Seitenaufteilung abschalten