AVR-Studio Simulator - EEPROM Auslesen bringt immer 0xFF

[Jaecko]

Moinsen.

Mal wieder ein Problem.
Für eine Aquariensteuerung (Mehrkanalschaltuhr etc.) schreib ich gerade das Programm. Die Hardware selbst ist noch nicht vorhanden, deshalb teste ich die Funktionen gerade im Simulator des AVR-Studio.

In diesem Programm sollen Werte für die Schaltzeiten im EEPROM abgespeichert werden. Beim Start des Programms sollen die Werte dann in Structs übernommen werden, die im RAM liegen.
Und genau da kommt das Problem: Aus noch unbekannten Gründen wird dort immer 0xFF ausgelesen.

Dabei ist es egal, welche der drei folgenden Aufrufe ich verwende:

  Channel[CH1].TH_Off = EEP_ReadByte(S_T1_OFFH);
  Channel[CH1].TH_Off = EEP_T1_OffH;
  Channel[CH1].TH_Off = EEP_ReadByte(EEP_T1_OffH);

Ich hab mal die betreffenden Dateien hier angehängt. Das gesamte Projekt liegt in nem .zip-Archiv ebenfalls mit dabei. Nicht wundern über die ganzen anderen "Baustellen".

Sieht hier jemand den Fehler?
Oder ist das wieder eines dieser Dinge, wo der Simulator einfach Mist baut?



EEP.c:

#include "eep.h"

// EEPROM-Variables

extern stc_TimeChannels Channel[8];


ui8_t  EEP_dummy      EEMEM = 0xFF; /* avoid Address 0x00 */

ui8_t  EEP_T1_OffH    EEMEM = 8;
ui8_t  EEP_T1_OffM    EEMEM = 30;
ui8_t  EEP_T1_OnH     EEMEM = 20;
ui8_t  EEP_T1_OnM     EEMEM = 15;
ui8_t  EEP_T2_OffH    EEMEM = 8;
ui8_t  EEP_T2_OffM    EEMEM = 0;
ui8_t  EEP_T2_OnH     EEMEM = 20;
ui8_t  EEP_T2_OnM     EEMEM = 0;
ui8_t  EEP_T3_OffH    EEMEM = 8;
ui8_t  EEP_T3_OffM    EEMEM = 0;
ui8_t  EEP_T3_OnH     EEMEM = 20;
ui8_t  EEP_T3_OnM     EEMEM = 0;
ui8_t  EEP_T4_OffH    EEMEM = 8;
ui8_t  EEP_T4_OffM    EEMEM = 0;
ui8_t  EEP_T4_OnH     EEMEM = 20;
ui8_t  EEP_T4_OnM     EEMEM = 0;
ui8_t  EEP_T5_OffH    EEMEM = 8;
ui8_t  EEP_T5_OffM    EEMEM = 0;
ui8_t  EEP_T5_OnH     EEMEM = 20;
ui8_t  EEP_T5_OnM     EEMEM = 0;
ui8_t  EEP_T6_OffH    EEMEM = 8;
ui8_t  EEP_T6_OffM    EEMEM = 0;
ui8_t  EEP_T6_OnH     EEMEM = 20;
ui8_t  EEP_T6_OnM     EEMEM = 0;
ui8_t  EEP_T7_OffH    EEMEM = 8;
ui8_t  EEP_T7_OffM    EEMEM = 0;
ui8_t  EEP_T7_OnH     EEMEM = 20;
ui8_t  EEP_T7_OnM     EEMEM = 0;
ui8_t  EEP_T8_OffH    EEMEM = 8;
ui8_t  EEP_T8_OffM    EEMEM = 0;
ui8_t  EEP_T8_OnH     EEMEM = 20;
ui8_t  EEP_T8_OnM     EEMEM = 0;
ui8_t  EEP_T1_State   EEMEM = 0;
ui8_t  EEP_T2_State   EEMEM = 0;
ui8_t  EEP_T3_State   EEMEM = 0;
ui8_t  EEP_T4_State   EEMEM = 0;
ui8_t  EEP_T5_State   EEMEM = 0;
ui8_t  EEP_T6_State   EEMEM = 0;
ui8_t  EEP_T7_State   EEMEM = 0;
ui8_t  EEP_T8_State   EEMEM = 0;


// EEPROM Addresses
#define S_T1_OFFH    1
#define S_T1_OFFM    2
#define S_T1_ONH     3
#define S_T1_ONM     4
#define S_T1_STATE   5


void EEP_LoadStartupVariables(void)
{
  /* copy variables from EEPROM to RAM */
  Channel[CH1].TH_Off = EEP_ReadByte(S_T1_OFFH);
  Channel[CH1].TM_Off = EEP_ReadByte(S_T1_OFFM);
  Channel[CH1].TH_On  = EEP_ReadByte(S_T1_ONH);
  Channel[CH1].TM_On  = EEP_ReadByte(S_T1_ONM);
  Channel[CH1].state  = EEP_ReadByte(S_T1_STATE);

  Channel[CH2].TH_Off = EEP_T2_OffH;
  Channel[CH2].TM_Off = EEP_T2_OffM;
  Channel[CH2].TH_On  = EEP_T2_OnH;
  Channel[CH2].TM_On  = EEP_T2_OnM;
  Channel[CH2].state  = EEP_T2_OffH;

  Channel[CH3].TH_Off = EEP_T3_OffH;
  Channel[CH3].TM_Off = EEP_T3_OffM;
  Channel[CH3].TH_On  = EEP_T3_OnH;
  Channel[CH3].TM_On  = EEP_T3_OnM;
  Channel[CH3].state  = EEP_T3_OffH;

  Channel[CH4].TH_Off = EEP_T4_OffH;
  Channel[CH4].TM_Off = EEP_T4_OffM;
  Channel[CH4].TH_On  = EEP_T4_OnH;
  Channel[CH4].TM_On  = EEP_T4_OnM;
  Channel[CH4].state  = EEP_T4_OffH;

  Channel[CH5].TH_Off = EEP_T5_OffH;
  Channel[CH5].TM_Off = EEP_T5_OffM;
  Channel[CH5].TH_On  = EEP_T5_OnH;
  Channel[CH5].TM_On  = EEP_T5_OnM;
  Channel[CH5].state  = EEP_T5_OffH;

  Channel[CH6].TH_Off = EEP_T6_OffH;
  Channel[CH6].TM_Off = EEP_T6_OffM;
  Channel[CH6].TH_On  = EEP_T6_OnH;
  Channel[CH6].TM_On  = EEP_T6_OnM;
  Channel[CH6].state  = EEP_T6_OffH;

  Channel[CH7].TH_Off = EEP_T7_OffH;
  Channel[CH7].TM_Off = EEP_T7_OffM;
  Channel[CH7].TH_On  = EEP_T7_OnH;
  Channel[CH7].TM_On  = EEP_T7_OnM;
  Channel[CH7].state  = EEP_T7_OffH;

  Channel[CH8].TH_Off = EEP_T8_OffH;
  Channel[CH8].TM_Off = EEP_T8_OffM;
  Channel[CH8].TH_On  = EEP_T8_OnH;
  Channel[CH8].TM_On  = EEP_T8_OnM;
  Channel[CH8].state  = EEP_T8_OffH;

}

ui8_t EEP_ReadByte(ui8_t address)
{
  ui8_t retval;
  retval = eeprom_read_byte(&address);
  return retval;
}

void EEP_WriteByte(ui8_t address, ui8_t value)
{
  eeprom_write_byte(&address, value);
}

EEP.h:

#ifndef _EEP_H_
#define _EEP_H_

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

#include "glob_defs.h"
#include "glob_type.h"

//#define EEP_SECT __attribute__ ((section (".eeprom")))


#define CH1 0
#define CH2 1
#define CH3 2
#define CH4 3
#define CH5 4
#define CH6 5
#define CH7 6
#define CH8 7


void EEP_LoadStartupVariables(void);
ui8_t EEP_ReadByte(ui8_t address);
void EEP_WriteByte(ui8_t address, ui8_t value);


#endif

Aufruf in der Main:

int main(void)
{
  // Init system

  EEP_LoadStartupVariables();   // Load variables from EEPROM
...

[Besserwessi]

Ich kann mich dunkel daran erinnern, dass man beim Simulator die EEPROM Daten erstmal von Hand laden mußte.
Werden denn die Daten beim Simulator auch wirklich ins EEPROM geladen ? Den EEPROM Inhalt kann man sich ja auch ansehen.
$FF ist ja den Inhalt für ein "leeres" EEPROM.

[Jaecko]

Beim Start des Simulators kommt die Frage (Sinngemäss):
Das Programm verwendet vordefinierte EEPROM-Daten. Laden? => Yes.

Im Memory-Window unter EEPROM sind dann die Daten auch korrekt vorhanden. Nur sobald dann davon gelesen werden soll (über die Funktionen in der eeprom.h), kommt 0xFF.

Direkt zu Fuss nach Datenblatt möcht ich die Funktionen auch nicht aufbauen, da ich ja dann im Prinzip auch nix anderes schreib, als in den bereits vorhandenen Funktionen schon drinsteht.

Das blöde hier ist ja jetzt, dass ich nicht weiss, ob es wirklich ein Programmierfehler von mir ist, oder ob hier das AVR-Studio einfach nicht so geht wie's soll.

Ich bin in solchen Dingen schon etwas vorgeschädigt, da ich sogar schon bei nem 1400-EUR-Debugger im Praxissemester Probleme hatte, die es eben nur dort gab. Auf der Hardware funktionierte es fehlerfrei.

[oberallgeier]

Hi Jaecko,

in der Hilfe vom AVRStudio "HTML Help" steht unter Simulator Overview u.a.
... When AVR Studio is launched, the simulator will reset all program memories, SRAM and EEprom to 0xFF. IO locations are set to 0x00...
und noch anderes dazu. Vielleicht findest Du dort ne Hilfestellung? Ist Dein ins "EEPROM" geladener File einer vom Typ *.hex oder *.eep ?

Aber wirklich helfen kann ich wohl nicht; damit hatte ich vor Monaten nur ein bisschen gespielt und nix wirklich Sinnvolles getestet.

[Jaecko]

Thx trotzdem schon mal.
Wo genau der Simulator die Daten herholt, weiss ich (leider) nicht. Wäre gut möglich, dass er sich die aus der .eep rausholt.

Werd dann mal mit nem anderen Bereich weitermachen und die EEPROM-Sache dann direkt an der Hardware testen, sobald die fertig aufgebaut ist.

[wkrug]

Soweit ich weiß, musst Du beim AVR Studio die EEProm Daten bei jedem Start des Studio mit Up/Download Memory die .eep Datei in den Simulator laden.
Ansonsten steht im EEPROM immer 0xFF.

[sast]

nur mal so als Idee

dein define S_T1_OFFH ist doch bestimmt die Adresse deines EEPROMs an der du auslesen willst

in

ui8_t EEP_ReadByte(ui8_t address)
{
ui8_t retval;
retval = eeprom_read_byte(&address);
return retval;
}

nimmst du aber noch mal die Adresse der address Variable. Mein Vorschlag wäre:

ui8_t EEP_ReadByte(ui8_t address)
{
ui8_t retval;
retval = eeprom_read_byte((ui8_t*)address);
return retval;
}

sast

[Jaecko]

Das mit der Adresse ist mir garnicht aufgefallen, aber scheints tatsächlich zu sein. Is ja dann auch logisch, dass er Käse liefert, wenn er an der Adresse des Parameters schaut und nicht im EEPROM.
Wenn ich die eeprom_read_byte direkt aufrufe (ohne den Funktionswrapper aussenrum) gehts. Das mit dem Cast hat auch nicht ganz geklappt.
Hab das jetzt einfach so gelöst, dass ich den Funktionsnamen einfach als Define ersetzen lass:

#define EEP_ReadByte(a) eeprom_read_byte(a)