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)???
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!
Um die Daten von einem DataFlash möglichst effizient in ein Display zu bekommen, hatte ich das mal folgendermassen gemacht:
1 | void display_sprite(uint16_t page, uint16_t byte, uint8_t x, uint8_t y, uint8_t w, uint8_t h) { |
2 | speed_inc(); |
3 | |
4 | mem_init_read(page, byte, 12); |
5 | |
6 | display_cmd((uint8_t *)0xef90, 0); |
7 | display_cmd((uint8_t *)0x0500, 0); |
8 | display_cmd((uint8_t *)(0x0800 | x), 0); |
9 | display_cmd((uint8_t *)(0x0900 | (x + w - 1)), 0); |
10 | display_cmd((uint8_t *)(0x0a00 | y), 0); |
11 | display_cmd((uint8_t *)(0x0b00 | (y + h - 1)), 0); |
12 | |
13 | SPDR = 0xff; |
14 | loop_until_bit_is_set(SPSR, SPIF); |
15 | RPO_D_RS &= ~_BV(PIN_D_RS); |
16 | for (uint16_t i = 0; i < w * h; ++i) { |
17 | loop_until_bit_is_set(SPSR, SPIF); |
18 | SPDR = SPDR; |
19 | loop_until_bit_is_set(SPSR, SPIF); |
20 | SPDR = SPDR; |
21 | }
|
22 | |
23 | loop_until_bit_is_set(SPSR, SPIF); |
24 | |
25 | RPO_MEM_CS |= _BV(PIN_MEM_CS); |
26 | RPO_D_CS |= _BV(PIN_D_CS); |
27 | |
28 | speed_dec(); |
29 | }
|
30 | |
31 | void mem_init_read(uint16_t page, uint16_t byte, uint8_t offset) { |
32 | RPO_MEM_CS &= ~_BV(PIN_MEM_CS); |
33 | RPO_D_CS |= _BV(PIN_D_CS); |
34 | |
35 | if (offset <= 4) { |
36 | offset = 4 - offset; |
37 | } else { |
38 | if (byte < offset - 4) { |
39 | page = (page - 1) & MEM_LASTPAGE; |
40 | byte = 264 - (offset - 4) + byte; |
41 | } else { |
42 | byte -= (offset - 4); |
43 | }
|
44 | offset = 0; |
45 | }
|
46 | |
47 | SPDR = MEM_OP_CONTREAD; |
48 | loop_until_bit_is_set(SPSR, SPIF); |
49 | SPDR = H8(page << 1); |
50 | loop_until_bit_is_set(SPSR, SPIF); |
51 | SPDR = L8(page) << 1 | H8(byte); |
52 | loop_until_bit_is_set(SPSR, SPIF); |
53 | SPDR = L8(byte); |
54 | loop_until_bit_is_set(SPSR, SPIF); |
55 | |
56 | for (; offset; --offset) { |
57 | SPDR = 0xff; |
58 | loop_until_bit_is_set(SPSR, SPIF); |
59 | }
|
60 | }
|
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.
Bitte 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.