Daten in den Flash Speicher schreiben

[Dennis A. (dede1989)]

Hallo,

für meine 8x8 LED-Matrix möchte ich 26 Arrays speichern in denen ich das 
Alphabet abbilden kann.

Beispiel:

unsigned char testbildA[64]={
    0,1,1,1,1,1,0,0,
    0,1,0,0,0,0,1,0,
    0,1,0,0,0,0,1,0,
    0,1,0,0,0,0,1,0,
    0,1,1,1,1,1,1,0,
    0,1,0,0,0,0,1,0,
    0,1,0,0,0,0,1,0,
    0,1,0,0,0,0,1,0
}

für die Darstellung eines A's.

Ich will das ganze mit nem Attiny 2313 realisieren. Würde ich nun 26 
Variablen speichern würde das ganz locker mal das Ram auf eine 
Auslastung von 1000% bringen. Geh also nicht.  Nun zur eigentlichen 
Frage: ist es möglich neben dem Programmcode Daten in den Flash Speicher 
zu schreiben? Dieser bietet ja am meisten Speicherplatz. Erst hatte ich 
mir überlegt das ganze in den EEprom zu schreiben. Da habe ich aber auch 
nur 128 Bytes insgesamt. Nicht ausreichend.

Viele Grüße Dennis

[Eumel (Gast)]

Ja, geht.
Siehe:
http://www.mikrocontroller.net/articles/AVR-Tutorial:_Speicher#Flash-ROM_2

[MWS (Gast)]

Das Schlüsselwort lautet Progmem, außerem ist's nicht sinnvoll für ein 
Bit ein Byte zu verschwenden.

[Dennis A. (dede1989)]

MWS schrieb:
> Das Schlüsselwort lautet Progmem, außerem ist's nicht sinnvoll für
> ein
> Bit ein Byte zu verschwenden.

Sehe ich auch so, jedoch gibt es meines Wissens kein boolean Datentyp.

[Stefan E. (sternst)]

Dennis Assenmacher schrieb:
> MWS schrieb:
>> Das Schlüsselwort lautet Progmem, außerem ist's nicht sinnvoll für
>> ein
>> Bit ein Byte zu verschwenden.
>
> Sehe ich auch so, jedoch gibt es meines Wissens kein boolean Datentyp.

Und was hindert dich daran, selber 8 Bits in ein Byte zusammenzufassen?

unsigned char testbildA[8]={
    0b01111100,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01111110,
    0b01000010,
    0b01000010,
    0b01000010
};

[Dennis A. (dede1989)]

Stefan Ernst schrieb:
> Und was hindert dich daran, selber 8 Bits in ein Byte zusammenzufassen?
> unsigned char testbildA[8]={
>     0b01111100,
>     0b01000010,
>     0b01000010,
>     0b01000010,
>     0b01111110,
>     0b01000010,
>     0b01000010,
>     0b01000010
> };

Nicht schlecht. Merci! Wobei ich da ein Problem habe durch die einzelnen 
Bits zu iterieren. Wenn ich sie darstellen will.

[Stefan E. (sternst)]

Dennis Assenmacher schrieb:
> Wobei ich da ein Problem habe durch die einzelnen
> Bits zu iterieren.

Nicht wirklich.

[MWS (Gast)]

Dennis Assenmacher schrieb:
> Sehe ich auch so, jedoch gibt es meines Wissens kein boolean Datentyp.

Du kannst 8 Bits zusammen als Char in einer Notation ablegen, die der 
Compiler akzeptiert. Der AVR GCC sollte 0b10101010 können, die Bits sind 
problemlos per Code zu extrahieren.

[c-hater (Gast)]

Dennis Assenmacher schrieb:
> Stefan Ernst schrieb:
>> Und was hindert dich daran, selber 8 Bits in ein Byte zusammenzufassen?
>> unsigned char testbildA[8]={
>>     0b01111100,
>>     0b01000010,
>>     0b01000010,
>>     0b01000010,
>>     0b01111110,
>>     0b01000010,
>>     0b01000010,
>>     0b01000010
>> };
>
> Nicht schlecht. Merci! Wobei ich da ein Problem habe durch die einzelnen
> Bits zu iterieren. Wenn ich sie darstellen will.

Wieso? Wenn du die Spaltenleitungen der Matrix "geordnet" an einen 
Byteport anschließt, brauchst du dich um einzelne Bits überhaupt nicht 
zu kümmern. Du holst einfach ein Byte aus der Matrix und gibst es 1:1 
auf den Spaltenport aus und fertig. Das ist die mit weitem Abstand 
effizienteste Lösung für Multiplexing.

Nur wenn das wegen Pinmangel nicht möglich ist, muß man überhaupt mit 
einzelnen Bits jonglieren. Und natürlich geht auch das, es ist bloß 
wesentlich ineffizienter.

[Dennis A. (dede1989)]

c-hater schrieb:
> Wieso? Wenn du die Spaltenleitungen der Matrix "geordnet" an einen
> Byteport anschließt, brauchst du dich um einzelne Bits überhaupt nicht
> zu kümmern. Du holst einfach ein Byte aus der Matrix und gibst es 1:1
> auf den Spaltenport aus und fertig. Das ist die mit weitem Abstand
> effizienteste Lösung für Multiplexing.
>
> Nur wenn das wegen Pinmangel nicht möglich ist, muß man überhaupt mit
> einzelnen Bits jonglieren. Und natürlich geht auch das, es ist bloß
> wesentlich ineffizienter.

Die Matrix ist schon fertig und ich steuere die Spalten mit nem 
Schieberegister an und die Zeilen mit nem Multiplexer. Fürs 
Schieberegister brauche ich dann halt den Zugriff auf die einzelnen Bits