Pointer vergleichen

[Michael (Gast)]

Hallo,
wie kann ich in winavr herausfinden, ob zwei Pointer auf die gleiche 
Adresse zeigen?
Ich hab den gesamten EEPROM als Fehlerspeicher belegt

uint8_t Fehler[512] EEMEM;

und will dann mit

if( FehlerZeiger == &Fehler[511] ) //Fehlerspeicher voll prüfung

prüfen, ob der Speicher voll ist.
Bekomme dann aber folgende Fehlermeldung: subscripted value is neither 
array nor pointer

[Stefan B. (stefan)]

Wie ist FehlerZeiger definiert?

[Michael (Gast)]

Fehlerzeiger ist wie folgt definiert:

uint8_t *FehlerZeiger; //Zeiger auf den letzten Fehler

[PointMe (Gast)]

Was sollen denn für Werte geschrieben werden ?

Vielleicht könnte man eine Stopp-Marke ans Ende des EEPROMS schreiben 
und diese dann nach dem Inkrementieren des Pointers abfragen.

Ein Adressenvergleich sollte mit &pointer1 == &pointer2 funktionieren.

[PointMe (Gast)]

Die Fehlermeldung kommt daher, weil Du eine Adresse mit einem Pointer 
vergleichst. Caste mal den Fehlerpointer dann sollte das gehen.

[Andreas K. (a-k)]

> sollte mit &pointer1 == &pointer2 funktionieren

Kaum.

> weil Du eine Adresse mit einem Pointer vergleichst

Was völlig i.O. ist. Eine Adresse ist ein Pointer.

> subscripted value is neither array nor pointer

Das klingt eher danach, als ob die Deklaration von Fehler[]
- nicht gesehen wird
- oder "EEPROM" unbekannt ist
- oder "Fehler" auch ein Präprozessor-Symbol ist
- oder irgendwas anderes in der Art.

[Klaus F. (kfalser)]

Der AVR hat verschiedene Adressbereiche für EEPROM und RAM, deshalb 
unterscheiden sich die Zeiger.

Dein Feld Fehler liegt im EEPROM :
uint8_t Fehler[512] EEMEM;

Dein Pointer ist aber ein "normaler" Pointer, und zeigt auf den 
RAM-Speicher:
uint8_t *FehlerZeiger;

Versuchs mal mit :
uint8_t EEMEM *FehlerZeiger;

Das sollte einen Zeiger auf EEMEM Speicher geben.

Klaus

[Stefan B. (stefan)]

Folgendes (nicht besonders sinnvolles) kompiliert bei MCU=atmega128 ohne 
Fehlermeldung:

#include <avr/io.h>
#include <avr/eeprom.h>

uint8_t Fehler[512] EEMEM;
uint8_t * FehlerZeiger = &Fehler[0];

int main(void)
{
    if( FehlerZeiger == &Fehler[511] ) //Fehlerspeicher voll prüfung
       /* EEPROM voll */ ;   
   
    while(1)
       ;

    return 0;
}

Du solltest vielleicht die komplette Problemsource angeben.

[Andreas K. (a-k)]

> deshalb unterscheiden sich die Zeiger.

An sich schon. Aber GCC ist leider nicht dafür bekannt, sich um solche 
Feinheiten zu kümmern.

Die Meldung kommt auch nicht vom "==" Operator, sondern von "[]". Und 
besagt dass er auf "Fehler" nicht anwendbar ist. Was "FehlerZeiger" ist, 
interessiert zu diesem Zeitpunkt noch garnicht.

[Michael (Gast)]

>>uint8_t EEMEM *FehlerZeiger;
funktioniert leider nicht. Selbe Fehlermeldung

Hier noch mal der der Sourcecode von log.c:

#include <avr/eeprom.h>

void SchreibeFehler( uint8_t Fehler );    //Schreibt Fehler ans Ende der Liste
void LoescheFehlerSpeicher( void );  //Löscht gesamten Fehlerspeicher
void InitialisiereSpeicher( void );  //ermittelt die position des letzten fehlers

uint8_t EEMEM *FehlerZeiger;        //Zeiger auf den letzten Fehler
uint8_t Fehler[512] EEMEM;      //gesamtes EEPROM als Fehlerspeicher
uint8_t SpeicherInitialisiert = 0;  //wurde speicher initialisiert?

void InitialisiereSpeicher( void )
{
  uint8_t tmpFehler;

  SpeicherInitialisiert = 1;
  FehlerZeiger = Fehler;      //zeiger auf ersten fehler initialisieren
  
  do
  {
    tmpFehler = eeprom_read_byte( FehlerZeiger++ );  //lese fehler aus
  }
  while( tmpFehler != 0xFF );    //0xFF kein Fehler geschrieben
  
  FehlerZeiger--;
  
}

void SchreibeFehler( uint8_t Fehler )
{
  if( SpeicherInitialisiert==0 ) InitialisiereSpeicher();  //initialisiere zuerst
  
  if( FehlerZeiger == &Fehler[0] )             //Fehlerspeicher voll prüfung
    eeprom_write_byte( ++FehlerZeiger, Fehler );

}

void LoescheFehlerSpeicher( void )
{
  
  for( uint16_t i=0; i<511; i++ ){
    eeprom_write_byte( &Fehler[i], 0xFF );
  }
}

Die Funktionen werden dann von main.c aufgerufen

[Andreas K. (a-k)]

void SchreibeFehler( uint8_t ==> Fehler <== )

[Karl H. (kbuchegg)]

Probiers mal so

  if( FehlerZeiger == Fehler )             //Fehlerspeicher voll prüfung

sollte ansich keinen Unterschied machen. Ich könnte mir aber
vorstellen, dass das EEMAM Attribut bei Fehler da irgend
einen Unterschied bewirkt.

[Andreas K. (a-k)]

Ok, dann deutlicher: mit -Wshadow übersetzen.

[Karl H. (kbuchegg)]

Andreas Kaiser wrote:
> Ok, dann deutlicher: mit -Wshadow übersetzen.

< Boing !>
(Geräusch, wenn die Stirn auf dem Tisch aufschlägt)

@Michael
Tus nicht, nenn einfach das Funktionsargument anders, so dass
der Compiler es vom globalen Array unterscheiden kann.

[Michael (Gast)]

Karl heinz Buchegger:
>>Tus nicht, nenn einfach das Funktionsargument anders, so dass
>>der Compiler es vom globalen Array unterscheiden kann.

Danke. Das war die Lösung. Im nachhinein hätte man da auch von selber 
drauf kommen können. Hatte wegen der komischen Fehlermeldung aber 
garnicht drauf geachtet.

[Karl H. (kbuchegg)]

Michael wrote:
> Karl heinz Buchegger:
>>>Tus nicht, nenn einfach das Funktionsargument anders, so dass
>>>der Compiler es vom globalen Array unterscheiden kann.
>
> Danke.

Andreas gebühren die Lorbeeren