Externes serielles EEPROM

hast du vielleicht ein beispielprogramm?

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!

Hat niemand etwas?
ich finde auch nichts dazu

möchte es mit einem VB Programm updatebar machen!

mfg

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

>@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...

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]

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.

Muß natürlich heißen: 65536 Bytes.

hab mich vertan.

Kann man jetzt auf die Adressen durchgehend zugreifen oder nicht?

mfg

@Sven Stefan

Gute erklärt! Jetzt bin ich schlauer geworden.

Funtktioniert Byteweises schreiben mit den gleichen Bedinungen die du 
erwähnt hast?

???

danke

Und hier der Link zum Datenblatt des 25AA512 (32 Seiten / 476kB):

http://www.datasheetarchive.com/pdf/4012139.pdf