absolute Adressen in C?

ne, das hilft mir gar nichts. Es geht ja darum, dass die restlichen 
Konstanten wirklich erst ab 0xE0000 im Flash stehen und eben nicht schön 
platzsparend aneiander gepappt werden.
In Assembler würde das so aussehen:
.org 0xD0000
.db .....//7200 float-Werte

.org 0xE0000
der Rest

ok, habe ich mir schon gedacht.
Ich werde mich vielleicht später nochmal damit beschäftigen, im Moment 
bleibts dann erstmal bei den dummy-Daten.
Bleibt die Frage, warum das nicht funktioniert:
const char dummy[0x10000-3*3600*4];
sollte eigentlich ein Array alegen, dass die restlichen Bytes bis zur 
64k-Grenze verbrät. Vertut aber 0x15740 Bytes statt 0x5740. Mach ich da 
einen Denkfehler oder spinnt der Compiler?

Verstehe, Du möchtest, dass der Compiler die Größe des Dummy-Feldes 
automatisch berechnet, und alle weiteren Variablen (nicht nur 
einzelne)danach anordnet.
Evtl. hilft es, mit  sizeof  die Größe der einzelnen chars und floats
und Array mal anzeigen zu lassen.

Was ich auch schon öfters hatte: Der Compiler rechnet Konstanten erstmal 
mit 16 Bits, außer man hängt ein L daran an.
Versuchs mal mit char dummy[65536L-3L*3600L*4L]

"Vertut aber 0x15740 Bytes statt 0x5740."
schon komisch, wenn dann hätte ich mir noch eher vorstellen können, dass 
er wg. Padding  2* 0x5700 reserviert.

Kannst Du mal hilfsweise das Dummy in zwei oder drei aufteilen und im 
Assembler nachschauen, was er wirklich macht, wohin er die arrays legt?

const char dummy1[8]=(0,1,2,3,4,5,6,7);
const char dummy2[0x57400-16];
const char dummy3[8]=(7,6,5,4,3,2,1,0);

Na, super :-)
Mit L klappte es wie gewünscht
habe es jetzt mit sizeof gelöst:
const char 
dummy[0x10000-sizeof(kennlinie1)-sizeof(kennlinie2)-sizeof(kennlinie3)];
passt :-)
Da wiederum brauch ich kein L.
Egal, vielen Dank

> Was ich auch schon öfters hatte: Der Compiler rechnet Konstanten
> erstmal mit 16 Bits, außer man hängt ein L daran an.

Genauer gesagt sind Konstanten vom Typ int, wenn dieser Typ groß genug 
ist. Ich nehme mal an, daß int beim gegebenen Controller 16 Bit breit 
ist. Wenn bei einer Berechnung alle Operanden vom Typ int sind, ist es 
auch das Ergebnis. 65536 passt zwar nicht mehr und ist daher sowieso 
long, aber 3, 3600 und 4 nicht. Das Ergebnis der zuerst ausgeführten 
Multiplikation ist also vom Typ int, aber die 43200 passen nicht mehr da 
rein. Durch den Überlauf ergibt sich stattdessen ein Wert von -22336. 
Erst danach wird dann zur Subtration wegen der 65536 auf 32Bit 
erweitert. Die Größe des Blocks ist also nicht 65536-43200=22336 
(=0x5740), sondern 65536+22336=87872 (=0x15740)

> Versuchs mal mit char dummy[65536L-3L*3600L*4L]

Damit gehst du auf Nummer Sicher. Theoretisch würde es auch rechen, nur 
bei einer der letzten drei Zahlen das L anzuhängen, aber mit allen Ls 
ist der Code leichter verständlich.