mehrfach gebrauch der SPI Schnittstelle

[Fritz F. (beni123)]

Hallo!! Hätte mal wieder eine Frage. Ich will mit meinen Mikricontroller 
von einen externen Speicher (über SPI) Daten hohlen und diese dann 
wieder an meinem PC (über Lanchip mit SPI) weitergeben. Muss ich jetzt 
also zuerst den Speicher selektieren die Daten auf den uC holen und dann 
den LANCHIP selektieren um sie weiter zu geben??? Nur was mache ich wenn 
ich eine große Menge an Daten übertragen will ( wo der interne Speicher 
des uC nicht mehr ausreicht zum zwischen Speichern)???

[Bertram S. (bschall)]

Einfach Stückerlweise das ganze an den LAN Chip senden!

[Fritz F. (beni123)]

Habe die Idee auch schon gehabt. Wollte nur wissen ob es vielleicht 
nicht doch irgend wie anders geht. Ist so dann doch etwas aufwendig und 
langsam! Vielleicht besorge ich mir auch einen anderen Speicher!

[Philipp B. (philipp_burch)]

Um die Daten von einem DataFlash möglichst effizient in ein Display zu 
bekommen, hatte ich das mal folgendermassen gemacht:

void display_sprite(uint16_t page, uint16_t byte, uint8_t x, uint8_t y, uint8_t w, uint8_t h) {
  speed_inc();

  mem_init_read(page, byte, 12);

  display_cmd((uint8_t *)0xef90, 0);
  display_cmd((uint8_t *)0x0500, 0);
  display_cmd((uint8_t *)(0x0800 | x), 0);
  display_cmd((uint8_t *)(0x0900 | (x + w - 1)), 0);
  display_cmd((uint8_t *)(0x0a00 | y), 0);
  display_cmd((uint8_t *)(0x0b00 | (y + h - 1)), 0);

  SPDR = 0xff;
  loop_until_bit_is_set(SPSR, SPIF);
  RPO_D_RS &= ~_BV(PIN_D_RS);
  for (uint16_t i = 0; i < w * h; ++i) {
    loop_until_bit_is_set(SPSR, SPIF);
    SPDR = SPDR;
    loop_until_bit_is_set(SPSR, SPIF);
    SPDR = SPDR;
  }

  loop_until_bit_is_set(SPSR, SPIF);

  RPO_MEM_CS |= _BV(PIN_MEM_CS);
  RPO_D_CS |= _BV(PIN_D_CS);

  speed_dec();
}

void mem_init_read(uint16_t page, uint16_t byte, uint8_t offset) {
  RPO_MEM_CS &= ~_BV(PIN_MEM_CS);
  RPO_D_CS |= _BV(PIN_D_CS);

  if (offset <= 4) {
    offset = 4 - offset;
  } else {
    if (byte < offset - 4) {
      page = (page - 1) & MEM_LASTPAGE;
      byte = 264 - (offset - 4) + byte;
    } else {
      byte -= (offset - 4);
    }
    offset = 0;
  }  

  SPDR = MEM_OP_CONTREAD;
  loop_until_bit_is_set(SPSR, SPIF);
  SPDR = H8(page << 1);
  loop_until_bit_is_set(SPSR, SPIF);
  SPDR = L8(page) << 1 | H8(byte);
  loop_until_bit_is_set(SPSR, SPIF);
  SPDR = L8(byte);
  loop_until_bit_is_set(SPSR, SPIF);

  for (; offset; --offset) {
    SPDR = 0xff;
    loop_until_bit_is_set(SPSR, SPIF);
  }
}

mem_init_read() initialisiert den Speicher, damit anschliessend alle 
Daten am Stück gelesen werden (Pro Taktzyklus ein Bit, keine Wartezeiten 
o.Ä. bei Pagegrenzen). Danach wird das Display entsprechend 
initialisiert, wobei aber darauf geachtet werden muss, dass bei diesem 
Vorgang Daten auch zum Speicher gelangen. Das ist nicht weiter tragisch, 
erzeugt jedoch einen Datenoffset, da bei jedem Kommando an's Display 
ein, bzw. zwei Bytes aus dem Speicher gelesen werden. Daher ist 
mem_init_read() auch mit etwas komischer Rechnerei versehen. 
Anschliessend wird in einer Schleife jedes Byte vom Speicher gelesen und 
mit dem gleichen (!) Takt das vorhergehende Byte an's Display gesendet.