www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik write und read Probleme bei Atmel Flash


Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>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

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
grrr..

Überzählige Wörter und Buchstaben darfst du behalten.

Oliver

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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?

Autor: Andreas Vogt (tico)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielleicht verrätst du mal, welches FLASH das ist. Noch besser wäre das 
Datenblatt als Dateianhang.

Oliver

Autor: Steff (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
benutze das Flash: at45db011

Kannst hoffentlich damit was anfangen.Mehr wie ich bestimmt

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>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

Autor: Andreas Vogt (tico)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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?

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Erstmal vielen Dank für eure super hilfe. Wollts nur mal sagen

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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?

Autor: Andreas Vogt (tico)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>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);

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>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):
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])
{
  uint8_t opcode = 0x82; // MAIN MEMORY PAGE PROGRAM;
  uint8_t adressfeld[3];

  /*
   An 8-bit opcode
   of 82H is followed by the six reserved bits and 18 address
   bits. The nine most significant address bits (PA8-PA0)
   select the page in the main memory where data is to be
   written, and the next nine address bits (BFA8-BFA0) select
   the first byte in the buffer to be written.
   */

  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

  // Los gehts
  SPI_PORT ~= (1<<SPI_CSB); // Set CSB to zero

  // opcode ausgeben
  S0SPDR = opcode; // Write command to SPI bus
  while (!(S0SPSR & (SPI_SPIF)))
    ; // Wait until data has been sent

  // pageadresse und startbyte ausgeben
  for (uint8_t i = 0; i < 3; i++)
  {
    S0SPDR = adressfeld; // Write data to SPI bus
    while (!(S0SPSR & (SPI_SPIF)))
      ; // Wait until data has been sent
  }
  // Daten ausgeben
  for (uint8_t i = 0; i < 15; i++)
  {
    S0SPDR = (uint8_t)(daten[i] >> 8); // Write data high byte to SPI bus
    while (!(S0SPSR & (SPI_SPIF)))
      ; // Wait until data has been sent

    S0SPDR = (uint8_t)(daten[i] & 0xff); // Write data low byte to SPI bus
    while (!(S0SPSR & (SPI_SPIF)))
      ; // Wait until data has been sent
  }

  SPI_PORT |= SPI_CSB; // Set CSB to one
}

Die entsprechende Lesefunktion kriegst du sicher selber hin.

Oliver

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Tausche
    S0SPDR = adressfeld; // Write data to SPI bus
gegen
    S0SPDR = adressfeld[i]; // Write data to SPI bus

Oliver

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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?

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>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?
page &= 0x1ff; // es dürfen nur 9 bit sein
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.
  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); ?


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

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielleicht ist es so einfacher zu verstehen:
uint32_t Bitfeld = (page << 9) + startbyte;

  // pageadresse und startbyte ausgeben
  for (uint8_t i = 0; i < 3; i++)
  {
    S0SPDR = (uint8_t)((Bitfeld >> ((3-i)*8)) & 0xff); // Write data to SPI bus
    while (!(S0SPSR & (SPI_SPIF)))
      ; // Wait until data has been sent
  }

Oliver

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>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

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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  ?

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>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

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>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

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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?!

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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?

Autor: Steff (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.