Hallo Ich will mit einem Atmega64 ein serielles EEPROM (SPI) beschreiben, lesen. Wenn ich über RS232 einen Text an den Atmega sende, soll dieser diesen Text in den EEPROM speichern. Es sollen ~100 Telefonnummern und ein Namen an den Atmega gesendet werden. Der Atmega soll anschließend an die Nummern die als String im EEPROM vorliegen eine SMS versenden. Hatt jemand ein gut dokumentiertes Programm für serielle EEPROMS? Ich verwende ein 25AA512 von Microchip. Wie kann ich einen String ins EEPROM schreiben? Vielen Dank
Schau Dir das Datenblatt vom EEPROM an und forme das benötigte Protokoll in der Firmware des Controllers nach. Das ist ein wenig Fleißarbeit und das kannst Du selber. Wie das SPI funktioniert, steht im Datenblatt des ATMega. Wenn Du das mal programmiert hast und kommst nicht weiter, kannst Du ja wieder fragen.
Junge raff es doch endlich: selber machen macht erst schlau. Dumme Fragen werden nun mal ungern beantwortet... Wenn du nicht in der Lage bist ein Software-SPI zu schreiben, dann hast du ein falsches Hobby gewählt. Selber suchen gehört nun mal dazu. Die Seite für alle deiner Fragen: http://www.gidf.de
@Dennis Investiere deine Zeit anderst als dumme Sprüche zu klopfen. Wenn du mir nicht helfen willst lass es eben!
Ja, die SPI-EEPROMs werden doch recht selten verwendet. Die meisten (ich auch) nehmen die I2C-EEPROMs 24C512 und dazu findet man dann auch Beispiele. Aber warum speicherst Du nicht einfach die Telefonnummern im Flash? Der ATmega64 hat doch massig davon. Dazu muß man nur eine Flashroutine in den Bootsektor schreiben. Oder man nimmt nen Bootloader mit integrierter Flashroutine (API-Call), die man dann von der Applikation aus aufruft. Peter
Hi >Hat niemand etwas? >ich finde auch nichts dazu Lass dein Rumgeheule. Sieh dir das Datenblatt von deinem EEPROM an und vergleiche das mit dem SPI-Interface vom ATMEGA64. Und dann Programmiere. Wenn du das nicht willst, solltest du dein Hobby überdenken. MfG Spess
schurli wrote:
> möchte es mit einem VB Programm updatebar machen!
Spricht doch nichts dagegen, z.B. über die UART.
Peter
>@Dennis >Investiere deine Zeit anderst als dumme Sprüche zu klopfen. Bist du dir sicher, das das dumme Sprüche waren??? Denn so gemeint waren sie eigentlich nicht. Erst denken, dann maulen. >Wenn du mir nicht helfen willst lass es eben! Aber natürlich helfe ich dir, siehe mein Posting oben!!! Vieviele hundert Links möchtest du denn haben, in denen Haarklein SW-SPI beschrieben wird??? http://www.gidf.de RTFM: http://atmel.com/dyn/resources/prod_documents/2490S.pdf, da steht auch viel über SPI drinn.... BTW: welche Programmiersprache wäre dir denn angenehm??? Bisher hast du uns diesbezüglich noch keinen Wunsch geäussert, wie wir dir diese armseligen 20 Zeilen SW-SPI vorkauen sollen...
ziehe CS nach Low, sende Deinen Befehl und danach dein Datum. Das Was´s. Du findest hier etwas. Vor einigen Wochen war jamand mit AVR und C hier, der seinen Code eingestellt hat. Und von mir findest du auch einen Teil davon für 8051. Einfach OBEN aus Suche gehen.
Habe noch ne Frage zur EEProm Sruktur:
Kann ich bei einem 512kByte EEprom auf 512*1024 Byte Adressen zugreifen?
Hier ein Programm aus dem Forum:
Warum weist er dem Zeiger einen Wert von 2 zu?
Hat das damit zu tun dass er 65534 Bits hat? (8kByte EEPROM)
mfg
[c]
//eeprom instructions
#define WREN 0x06
#define WRDI 0x04
#define RDSR 0x05
#define WRSR 0x01
#define READ 0x03
#define WRITE 0x02
void spi_init(void); //initialize
spi interface
unsigned char spi_transfer(unsigned char data); //transmit
data via spi
void spi_eeprom_write(unsigned int adress, unsigned int data); //write
data to external eeprom via spi
unsigned int spi_eeprom_read(unsigned int adress); //read data
from external eeprom via spi
int main(void)
{
//init ports
DDRB = 0xFF;
PORTB = 0xFF;
DDRC = 0x00;
PORTC = 0x00;
DDRC = 0xFF;
PORTC = 0x00;
spi_init();
spi_eeprom_write(0,1);
unsigned int data = spi_eeprom_read(0);
for(;;);
}
void spi_eeprom_write(unsigned int adress, unsigned int data)
{
adress *= 2;
unsigned char dummy;
if (adress < 65534)
{
PORTB &= ~(1<<CS); //pull
chip select low
dummy = spi_transfer(WREN);
//transmit write enable instruction
PORTB |= (1<<CS); //pull
chip select high
_delay_ms(1);
PORTB &= ~(1<<CS); //pull
chip select low
dummy = spi_transfer(WRITE);
//transmit write instruction
dummy = spi_transfer((unsigned char) adress>>8);
//transmit adress MSB
dummy = spi_transfer((unsigned char) adress);
//transmit adress LSB
dummy = spi_transfer((unsigned char) data>>8);
//transmit data MSB
dummy = spi_transfer((unsigned char) data);
//transmit data LSB
dummy = spi_transfer(WRDI);
//transmit write disable instruction
PORTB |= (1<<CS); //pull
chip select high
}
} //end of eeprom_write
unsigned int spi_eeprom_read(unsigned int adress)
{
unsigned char dummy;
unsigned int data = 0;
PORTB &= ~(1<<CS); //pull chip
select low
dummy = spi_transfer(READ); //transmit
write enable instruction
dummy = spi_transfer((unsigned char) adress>>8); //transmit
adress MSB
dummy = spi_transfer((unsigned char) adress); //transmit
adress LSB
data += (8<<spi_transfer(0x00)); //read data
LSB by dummy transmission
data += spi_transfer(0x00); //read data
MSB by dummy transmission
PORTB |= (1<<CS); //pull chip
select high
return data;
} //end of spi_eeprom_read
void spi_init(void)
{
DDRB |= (1<<PB3) | (1<<PB5); //set MOSI
and SCK output
DDRB &= ~(1<<PB4); //set MISO
input
SPCR = (1<<SPE) | (1<<MSTR); //enable
spi, master, clock rate f_cpu/4
} //end of spi_init
unsigned char spi_transfer(unsigned char data)
{
SPDR = (unsigned char) data; //transmit
data
while (!(SPSR & (1<<SPIF))); //wait for
transmission complete
return SPDR;
[\c]
es sind Seiten von 256 Byte. Der Counter ist selbst incrementierend und macht nach FF Roll over. Also dann neue Adresse setzen. Keine Ahnung was er mit 2us macht. Beim Lesen gibt es keine Zeiten in diesem Bereich. Beim Schreiben pro Page oder Byte eben 4-5 ms
Mir stehen bei 512kByte 524288 Byte zu verfügung. Kann ich direkt auf Adresse 5242.. zugreifen (schreiben,lesen)?
Hast Du das Datenblatt immer noch nicht gelesen? 25AA512 ist ein 512 KBit-EEPROM, das heißt 56536 Bytes.
hab mich vertan. Kann man jetzt auf die Adressen durchgehend zugreifen oder nicht? mfg
@schurli (Gast)
>Kann man jetzt auf die Adressen durchgehend zugreifen oder nicht?
Warum sollte man nicht?
Page Size ist nur für das Schreiben relevant.
MFG
Falk
Ja, kann man. Beim seitenweisen lesen sollte man aber den Zeiger immer auf den Anfang einer Seite setzen (also in diesem Fall auf ein Vielfaches von 128), da es sonst passieren kann das er dir Daten von zwei Seiten mischt, da serielle EPROMS immer nur den internen Zähler für die einzelnen Bytes innerhalb der Seite hochzählt nicht aber den Zähler für die Seite. Wenn du also den Adresszeiger auf Byte 64 von Seite 0 setzt und du die nächsten 128 Bytes lesen willst (was also 64 Bytes von Seite0 und 64 Bytes von Seite1 wären), wird er dir dir hinteren 64 Bytes von Seite0 und dannach die vorderen 64 Bytes von Seite0 zurück geben, da er den Seitenzähler nicht automatisch erhöht. Einzelne Bytes können aber direkt Adressiert werden und kommen auch richtig zurück. Du kannst auch nur 4 oder 8 Bytes holen, musst aber auch hier auf die Seitengrenzen achten (es geht also nicht von Adresse 124, 8 Bytes zu lesen, da hier wieder ein Seitenwechsel statt findet). Sven
@Sven Stefan Gute erklärt! Jetzt bin ich schlauer geworden. Funtktioniert Byteweises schreiben mit den gleichen Bedinungen die du erwähnt hast?
NEIN. Wenn das EEPROM in Pages organisiert ist, muß immer eine gesamte Page geschrieben werden, auch wenn man nur ein einziges Bit eines Bytes innerhalb dieser Page geändert haben will. Die Struktur der Befehle und die genaue Abfolge der Steuersignale und das Timing entnimmst Du vielleicht dann doch dem Datenblatt.
@Travel Rec. (travelrec) >NEIN. Wenn das EEPROM in Pages organisiert ist, muß immer eine gesamte >Page geschrieben werden, auch wenn man nur ein einziges Bit eines Bytes >innerhalb dieser Page geändert haben will. Stimmt nicht. Wir reden über EEPROM, nicht FLASH! Siehe Speicher MFG Falk
Die üblichen EEPROMs besitzen alle solche Pages. Anders als bei Flash-ROMs kann man die Daten trotzdem byteweise schreiben. Man kann die Pages benutzen um Zeit zu sparen - man muss es aber nicht.
Zitat aus dem Datahseet Seite 8 "Up to 128 bytes of data can be sent to the device before a write cycle is necessary. The"
allerdings: "When doing a write of less than 128 bytes the data in the rest of the page is refreshed along with the data bytes being written." Er macht es also selber intern.
@Travel Rec. (travelrec)
>Hier mal ein Ausschnitt aus dem DB - für alle zum Mitlesen
Ja eben. Byte and Page-level write operation. ;-)
MfG
Falk
Und hier der Link zum Datenblatt des 25AA512 (32 Seiten / 476kB): http://www.datasheetarchive.com/pdf/4012139.pdf
>Ja eben. Byte and Page-level write operation. ;-)
Darum hab ich´s doch ´reingestellt. Lesen bildet ;-)
Was auch immer mir sagen wollt, ich hab hier jedenfalls momentan einen 24C256 seriellen EEPROM (I2C) in der Mache und der schreibt auch einzelne Bytes und kann auch einzelne Bytes lesen. Derzeit schreibe ich immer 8 Bytes hintereinander und lese auch 8 Bytes hintereinander obwohl die Seitengröße mit 64 Bytes angegeben ist. Bei meinen ersten Tests vor 2 Wochen hatte ich nur einzelne Bytes geschrieben und gelesen und das ging auch. Schau dir halt das DB zu deinem EPROM an. Am genauesten siehst du es bei den Taktdiagrammen wie du die Daten zu senden und zu lesen hast. Sven
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.