ptr_to_eeprom= &Light_time_data_ee[0][0];
ptr_to_ram= &Light_time_data[0][0];
for (loop=0;loop<sizeof (Light_time_data_ee) ;loop++)
*ptr_to_ram++=*ptr_to_eeprom++;
Also ein Array wird vom Eeprom ins RAM kopiert, funktioniert auch
richtig.
Es gibt allerdings Warnungen.
-a value of type 'eeprom unsigned int' was assigned to an entity of typ
-a value of type 'unsigned int' was assigned to an entity of typ
Gibts ne Möglichkeit, die Adresse eines
Arrays anders anzugeben? Ich habs lieber, wenn es keine Warnungen gibt
:-)
Winnie schrieb:> Gibts ne Möglichkeit, die Adresse eines> Arrays anders anzugeben? Ich habs lieber, wenn es keine Warnungen gibt> :-)
so vielleicht?:
ptr_to_eeprom= Light_time_data_ee;
ptr_to_ram= Light_time_data;
ob das dein Problem behebt, weiß ich nicht...
Winnie schrieb:> Gibts ne Möglichkeit, die Adresse eines> Arrays anders anzugeben? Ich habs lieber, wenn es keine Warnungen gibt> :-)
Dann schau dir die Zuweisungen an
Die Zuweisung
1
ptr_to_eeprom=&Light_time_data_ee[0][0];
hat einen Teil links vom = und einen Teil rechts vom =
Der Teil links vom = lautet
1
ptr_to_eeprom
Frage: welcher Datentyp verbirgt sich hinter dieser Variablen (wie ist
sie deklariert)?
Der Teil rechts vom = lautet
1
&Light_time_data_ee[0][0
Und wieder die gleiche Frage: welcher Datentyp steckt in diesem
Ausdruck.
Der & ergänzt den Datentyp nur um eine Pointerkomponente. Der Basis-
datentyp bleibt aber derselbe:
wenn c vom Typ char ist ( char c; )
dann hat &c den Datentyp Pointer auf char ( char * )
wenn d vom Typ double ist ( double d; )
dann hat &d den Datentyp Pointer auf double ( double * )
wenn s vom Typ volatile unsigned int ist ( volatile unsigned int s; )
dann hat &s den Datentyp Pointer auf volatile unsigned int
( volatile unsigned int * )
wenn t den Datentyp constante Struktur 'MyStruct' hat
( const struct MyStruct t; )
dann hat &t den Datentyp Pointer auf constante Struktur 'MyStruct'
( const struct MyStruct * )
Also: welcher Datentyp steht links vom =, welcher Datentyp steht rechts
vom =?
Die vergleichst du und stellst fest, wo sie nicht zusammenpassen. Dann
entscheidest du, ob der Unterschied harmlos ist, oder ob da eine
spezielle Aktion notwendig ist. Wenn der Unterschied harmlos ist, dann
kannst du das dem Compiler mitteilen: Sieh mal, ich weiß das das
eigentlich nicht zusammenpasst, aber als Programmierer sag ich dir - das
passt schon so.
Und in C Schreibweise ist das nun mal ein Cast. Du castest den Ausdruck
rechts vom = auf denselben Datentyp, der links vom = steht. Damit stehen
dann aus Sicht des = links und rechts dieselben Datentypen und es gibt
für den Compiler keinen Grund mehr, eine Warnung zu werfen.
Eigentlich ganz einfach, wenn man begriffen hat, das Variablen nicht nur
einen Wert haben, sondern auch einen Datentyp und das der Compiler sich
die Datentypen ansieht und die nicht einfach nur Dekoration sind.
Hm, Danke, habs aber immer noch nicht geschnallt, wo das Problem ist.
int eeprom *ptr_to_eeprom;
int *ptr_to_ram;
Es sind sowohl im Eeprom als auch im Ram int-Variable.
Winnie schrieb:> Hm, Danke, habs aber immer noch nicht geschnallt, wo das Problem ist.>>> int eeprom *ptr_to_eeprom;> int *ptr_to_ram;>> Es sind sowohl im Eeprom als auch im Ram int-Variable.
und was ist "eeprom"?
poste doch mal den kompletten Code
Hmm, es wurde doch schon geschrieben.
Karl Heinz Buchegger schrieb:> Also: welcher Datentyp steht links vom =, welcher Datentyp steht rechts> vom =?
Deine 2d Arrays haben welchen Datentyp?
Winnie schrieb:> int eeprom
und den Variablentyp gibt es da?
Winnie schrieb:> -a value of type 'eeprom unsigned int' was assigned to an entity of typ> -a value of type 'unsigned int' was assigned to an entity of typ
Da steht, daß der Compiler dich davor warnt, daß du in eine 'eeprom
unsigned int'-Variable in eine 'unsigned int'-Variable schreibst.
Also sage ihm, daß du das in Ordnung findest:
>ptr_to_eeprom= &Light_time_data_ee[0][0];
ptr_to_eeprom= (eeprom unsigned int*)&Light_time_data_ee[0][0];
mfg.
Das ist mehr oder weniger der gesamte Code, zumindest der, der das
Problemchen verursachst.
eeprom unsigned int Light_time_data_ee [8][4];
unsigned int Light_time_data[8][4];
void main(void)
{int eeprom *ptr_to_eeprom;
int *ptr_to_ram;
unsigned char loop;
ptr_to_eeprom=& Light_time_data_ee;
ptr_to_ram=& Light_time_data;
for (loop=0;loop<sizeof (Light_time_data_ee) ;loop++)
*ptr_to_ram++=(long)*ptr_to_eeprom++;
while (1)
{
}
}
Winnie schrieb:> mehr oder weniger
Mit mehr oder weniger Info kannst du beim Pater deines Vertrauens
Lebenshilfe bekommen.
Sollen hier alle rumraten, oder was wird das?
Winnie schrieb:> das long wegdenken :-)
Nein, ich denke mir nichts weg und nichts dazu.
Liefere konkrete Info, dann bekommst du auch genau darauf Antworten.
Natürlich ist das Programm ein wenig länger, es ist aber niemanden damit
gedient, 1400 Zeilen einzustellen...
Also habe ich es auf das gekürzt, was wesentlich ist und die Warnung
schmeisst. Es wird beim kopieren noch mit 60 multipliziert (daher das
long), im EEprom stehen minuten, im RAM-Array will ich dann die Sekunden
haben (das sind long-Variablen). Aber das ist auch sekundär. Ich finde -
je weniger, desto besser.
eeprom unsigned int Light_time_data_ee [8][4];
unsigned int Light_time_data[8][4];
void main(void)
{int eeprom *ptr_to_eeprom;
int *ptr_to_ram;
unsigned char loop;
ptr_to_eeprom=& Light_time_data_ee;
ptr_to_ram=& Light_time_data;
for (loop=0;loop<sizeof (Light_time_data_ee) ;loop++)
*ptr_to_ram++=*ptr_to_eeprom++;
while (1)
{
}
}
Winnie schrieb:> Natürlich ist das Programm ein wenig länger, es ist aber niemanden damit> gedient, 1400 Zeilen einzustellen...
das kannst du ja dem überlassen, der gerne antworten möchte
> for (loop=0;loop<sizeof (Light_time_data_ee) ;loop++)
das wird nicht das tun, was du dir davon erwartest. sizeof liefert die
Größe in Bytes. Und es ist ziemlich unwahrscheinlich, dass ein unsigned
int auf deinem System eine sizeof von 1 hat :-)
Tja, sonst heisst es immer:
-es ist unhöflich, Riesenprogramme einzustellen
-selbst eingrenzen und den Teil posten, der nachvollziehbar das Problem
verursacht.
Ok, ist dann auch wieder nicht recht :-(
Ich sollte mir wohl mal ein C-Buch kaufen, der Tip fehlt auch noch...
Ich mach einfach meinen Frieden mit den Warnungen
@Thomas Eckmann:
ptr_to_eeprom=(eeprom unsigned int*) & Light_time_data_ee[0][0];
ändert nichts.
Falls dennoch jemand eine Idee hat, würde ich mich freuen.
ist keine gute Idee.
Wenn LIght_time_data_ee ein Array von unsigned int ist, dann ist ein
Element aus dem Array logischerweise ein unsigned int.
Ein Pointer darauf sollte daher ein Pointer auf unsigned int sein, und
nicht ein Pointer auf int.
Seinen Compiler anzulügen ist meistens keine gute Idee. Manchmal merkt
der das sogar und beschwert sich mit einer Warning :-)
Winnie schrieb:> Ich mach einfach meinen Frieden mit den Warnungen> @Thomas Eckmann:> ptr_to_eeprom=(eeprom unsigned int*) & Light_time_data_ee[0][0];> ändert nichts.>> Falls dennoch jemand eine Idee hat, würde ich mich freuen.
Ja, nimm meinen Tip von oben ernst!
Deshalb hab ich ihn dir gegeben.
Welcher Datentyp steht links vom =, welcher Datentyp steht rechts davon.
Das ist das um und auf um mit Datentypen, mit Problemen bei der
Auswertung von Ausdrücken und mit seltsamen Fehlern umzugehen.
Lern es und mach es! Jetzt!
(PS: in deinem Fall ist der Cast keine gute Idee. Denn du hast vorher
schon deinen Compiler angelogen. Frag dich doch einfach mal, warum
eigentlich ptr_to_eeprom ein Pointer auf einen int ist, während das
Array vom Type unsigned int ist.)
unsigned int eeprom *ptr_to_eeprom;
unsigned int *ptr_to_ram;
Das wars :-), wie blöd von mir. Ich dachte, es reicht, wenn der pointer
weiss, wie gross die Variablen sind.
mit sizeof hast du natürlich auch recht, bei mir steht die magic 32 drin
:-)
1000 Dank!
kostet dich nichts und du hast die Gewähr, dass
* die beiden Arrays immer gleich gross sind
* die Schleifensteuerung korrekt gross ist
* du bei einer Änderung nichts übersehen kannst.
Du brauchst mehr Spalten? Kein Problem, mach LIGHT_COLS größer
und um den Rest kümmert sich der Compiler.
Lass den Compiler für dich arbeiten!
mal ne zwischenfrage, muss man sich extra pointer machen um auf die
arrays zu zeigen fürs rumkopieren? was spricht dagegen die arrays direkt
dafür zu verwenden? also:
eeprom unsigned int Light_time_data_ee [8][4];
unsigned int Light_time_data[8][4];
void main(void)
{unsigned char loop;
for (loop=0;loop<sizeof (Light_time_data_ee) ;loop++)
**(Light_time_data++)=**(Light_time_data_ee++);
while (1)
{
}
}
so ungefähr.
