www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Speichern und lesen eines internen EEPROMs


Autor: patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo zusammen

Ich habe ein Problem und möchte gerne eure Hilfe beanspruchen.


Ich will mit meine (Analog Devices) ADuC7060 das interne EEPROM 
verwenden.
Also habe ich im Datenblatt gelesen und auch im Internet und habe keine 
Hinweise, die mir weiter helfen könnte, gesehen.Ich möchte gern aus dem 
ADC Register (ADC0DAT) der Wert gewandelte per Tasterdruck nehmen und 
ihn im EEPROM speichern und der Wert muss dann automatisch gelesen 
werden und von aktuellen Wert des AD_Wandlers immer abgezogen. Ich habe 
es noch nie gemacht und hoffe dass ihr schon so etwas gemacht habt.
Also kann mir vielleicht jemand ein C Code Beispiel zeigen wo das EEPROM 
beschrieben und gelesen wird?
Oder sonst ein gute Seite zu diesem Problem. Denn ich habe wie es 
scheint das ganze EEPROM Zeugs noch nicht richtig Begriffen.

Ich danke euch schon einmal.

Gruss Patrick

Autor: Anton (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Den ADuC7060 kenne ich (noch) nicht.

Beim ADuC832 z.B. ist der EEPROM Zugriff ganz einfach:
Es werden betimmte Register für die Daten, die Adresse im EEPORM
und die Funktion beschrieben. Das EEPROM-Handling läuft intern 
automatisch
ab. Dürfte beim ADuC7060 ähnlich sein, (andere AVRs z.B. machen es auch 
so)
Das Steht alles im Datenblatt, meist unter Memory-EEPROM.

Autor: patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke Anton,
Ich habe es von Anfang an vermutet und habe direkt die Register gesucht 
und habe versucht die zu initialisieren aber das Problem bleibt fast 
ganz weil ich keine weitere Rechnungen  machen kann. Ich möchte nämlich 
der gespeicherte Wert wieder lesen und von dem aktuellen abziehen. 
Leider ist der AD-Wandler Register nicht beeinflussbar. Ich kann also 
die Berechnung auf dieser Niveau nicht machen.

Autor: Wadim Popov (wadim)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also, wenn ich dich richtig verstanden habe, willst du den ADC auslesen 
und diesen Wert in dem Flash/EE Speicher (also im Bereich 0x80000 bis 
0x87fff)ablegen und dann noch weitere Berechnungen machen und wieder 
ändern.

Hmmm...wieso verwendest du nicht einfach den ganz normalen SRAM 
(0x40000-0x40fff)??? Weil der Flash/EE ist ja nicht ganz so schnell und 
deshalb stehen dort immer nur die Konstanten, die niemals verändert 
werden.

Allerdings wenn du den ADC-Wert auch nach dem Reset oder dem Abschalten 
des µC verwenden möchtest, dann musst du den Wert in den ROM speichern. 
Dazu gibt es im Inet auf der Seite 
http://www.analog.com/en/analog-microcontrollers/a... 
eine Library, da sind auch Beispiele drin wie du den ROM löschen und 
wieberbeschreiben kannst.

Übrigens welchen Compiler verwendest du?

Also sag mir bitte Bescheid, ob unbedingt den ROM verwenden möchtest und 
dir der SRAM überhaupt nicht passt...dann können wir an dem C-Code 
arbeiten

mfg Wadim

Autor: patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi Wadim,
Ich arbeite mit Keil (µVision3)
Ich möchte beliebig den Wert des AD-Wandler auf Null setzen (abgleichen) 
deswegen möchte ich dieser Wert von ADC Register lesen und ihn im EEPROM 
speichern sodass dieser Wert sich nicht ändert auch wenn man das System 
abschaltet und wieder anschaltet. Dieses Verfahren möchte ich nutzen um 
mein Signal einzustellen. Es muss also im EEPROM gespeichert werden.
Ich habe verschiedene Varianten schon versucht aber komme noch nicht 
weiter.

Autor: Wadim Popov (wadim)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also, wie schon geschrieben, im Inet findest du eine Library. Dort 
findest du eine Assemblerdatei FeeWr.s...diese kannst du in dein Projekt 
einbinden.

So...weiter kannst du nach dem gleichen Prinzip, wie in main.c vorgehen.

Du erstellst eine Konstante:
static const int i3 = 0x12345678;
const int *pi3=&i3;
und im richtigen Moment überschreibst du diese Konstante...
FeeWr((char*)&i3,(char*)pi3,4);

weiter kannst du die i3 ganz normal lesen und sie für deine weitere 
Berechnungen verwenden.

das wäre die einfachste Lösung (glaube ich)...

Hoffe, dass das dir weiterhilft.

mfg Wadim

Autor: patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Wadim,
ich habe leider ohne erfolg die von dir vorgeschlagene Lösung versucht. 
Ich weiß nicht warum es immer noch nicht funktioniert.Kann man diese 
Aufgabe nicht anders lösen?

Autor: Wadim Popov (wadim)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Natürlich geht es auch anders, aber ich wüsste gerade nicht wie... Ich 
sehe, dass ich in der Zeile mit FeeWr ein kleines Fehler gemacht habe. 
Da müssen die Pointer richtig eingefügt werden, aber wie das geht kann 
man ja in dem Beispiel nachschauen...

Leider kenne ich mich nicht so gut mit Keil aus, ich arbeite mit IAR, 
aber ich weiss, dass du ne Menge Einstellungen machen musst und die 
ganzen nötigen Header-Dateien einfügen sollst, um das Projekt zum Laufen 
zu bringen.

Man kann in IAR sogennante sections (ich glaube auf deutsch nennt man 
diese "Sektoren")erstellen und ihnen eine bestimmte Speicheradresse und 
Speicherweite geben. In diese sections kannst du dann deine Funktionen 
und Variablen ablegen, aber wie das in Keil geht, musst du schon selber 
im Handbuch nachlesen...ich weiss nur, wie das in IAR geht.

Ich versuch dann mal in IAR ein Projekt zu erstellen, welches dann das 
macht, was du willst... Dann schauen wir mal, wie man das unter Keil 
auch machen kann

Autor: patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich vermute der unterschied zwischen Keil und IAR ist nicht groß.Ich 
habe zum Beispiel einige Quellcode von Keil und IAR verglichen und habe 
keine Unterschied bei der Schreibweise gefunden.
Ich habe vorhin alles noch einmal versucht aber etwas scheint nicht gut 
zu funktionieren.
Ich habe einen Pointer auf ADC Register zeigen lassen

ADC0data_ptr = ( unsigned long*)0xFFFF051C;

dann habe ich der Wert einer Variablen zugewiesen

ulADC0Result = *ADC0dadta;
Dieser Wert habe ich versucht in EEPROM zu speichern wahrscheinlich 
läuft da etwas schief weil ich nicht mehr der gespeicherte Wert lesen 
kann.
Also wie kann ich besser ab hier dieser Wert Speichern und wieder lesen?

Danke für deine Hilfe

Gruß

patrick

Autor: Wadim Popov (wadim)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe etwas mit den FEE Registern rumexperementiert, aber bei mir 
kommt auch nicht gescheites raus. Der liefert mir später einen falschen 
Wert aus und ich verstehe nicht wieso.

Ich arbeite gerade an meinem Projekt und habe vor kurzem einen 
Bootloader geschrieben. Der soll mir Bereiche meines ROMs löschen und 
wiederbeschreiben (jeweils 512Byte), da Funktioniert alles pikobello.

Dazu habe ich noch im ROM Speicherplatz reserviert und dort paar 
konstanten abgelegt, aber das habe ich mir iar gemach und ich weiss 
nicht, wie das in Keil gemacht werden soll. Da sollte ich in so einer 
Konfigurattionsdatei rumpfuschen.

ich bin jetzt bei der Arbeit, wenn ich zu Hause bin, versuche ich 
weiter...

mfg Wadim

Autor: patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das denke ich auch alles was hier noch stört sind diese Register 
besonders FEEDAT und FEEADR.
Z.B ist im Datasheet unter FEECON
0x01   single read:   Load FEEDAT with the 26-bit data. Indexed by 
FEEADR.
0x02   single write:  Write FEEDAT at the address pointed to by FEEADR.

Alles wird nur hier gemacht. Ich habe auch etwas gespeichert aber beim 
Lesen war nicht mehr das selbe.

Ich versuche weiter....

Autor: patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hallo zusammen,
Kann keiner also mir sagen wie ich einen Wert aus dem ADC-Register holen 
und ihn in einem internen EEPROM des ADuC7060 speichern kann?
Ich habe echt keine Ahnung mehr wie ich jetzt noch vorgehen könnte. Ich 
schätze viele arbeiten nicht mit Analog Devices.
Falls jemand eine Idee hat kann er immer weiter geben vielleicht hilft 
das

danke

patrick

Autor: Wadim Popov (wadim)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also...ich habe gestern Paer Sachen probiert und habe versucht mich mit 
dem Keil vertraut machen, aber ohne Erfolg. Wie schon geschrieben ich 
habe in IAR fast das Gleiche gemacht, was du brauchst. In IAR gibt es so 
eine Linker-Datei ADuC7060Ex.icf dort kannst du dein Speicher verwalten 
und dir Speicherbereiche für Konstanten und Funktionen reservieren.

Ich habe für meine Zwecke im hinteren Teil des ROMs einen Speicherplatz 
von 512Byte reserviert und dort Paar Daten abgelegt. Dann wenn ich diese 
Daten brauche zu ändern, strate ich meinen selbstgeschriebenen 
Bootloader und überschreibe dieses Segment.

Finde eine Möglichkeit, wie du in Keil den Speicherplatz reservieren und 
dort einige deiner Daten ablegen kannst. Sagen wir mal bei der 
Startadresse 0x87600 und Länge von 512Byte also 0x200. Dann kannst du 
mit den Funktionen FeeClr und FeeWr weiterarbeiten.

Hier ist ein Ausschnitt meines Bootloaders
da sendet der PC, welche Option gewählt werden soll. Für dich sin 0x04 
und 0x05 relevant.

static volatile unsigned char  uartFlash[512]; //Speicher für die Daten
unsigned char segment=0; //Nummer des zu beschreibenden Segments (0..63)
...

case 0x04: //Flashe Segment x
          while((COMSTA0&BIT0)!=BIT0){} //Wartet auf Nummer des Segmentes (0..63)
          segment=COMRX; 
          FeeClr((char*)(0x80000+(segment*0x200)),(char*)(0x80000+(segment*0x200))); //Lösche Segment x
          FeeWr((char*)(0x80000+(segment*0x200)),(char*)&uartFlash[0],512); //Flashe Segment x
          COMTX = 0x90; //synchronisation mit PC
          while ((COMSTA0 & 0x40) == 0x00){}
        break;
        
      case 0x05: //Vergleich Flash mit Data
        while((COMSTA0&BIT0)!=BIT0){} //Wartet auf Nummer des Segmentes (0..63)
        segment=COMRX;
        checksum=0;
        i=0;
        FEEADR=(segment*0x200); 
        while(i<512){
          FEEADR=(segment*0x200)+i;
          FEECON=0x01; //Daten aus Adresse FEEADR lesen
          checksum=checksum^FEEDAT; //LSByte von FEEDAT
          checksum=checksum^(FEEDAT>>8); //MSByte von FEEDAT
          ++i;++i;
        }
        COMTX = checksum; //checksumme an PC senden
        while ((COMSTA0 & 0x40) == 0x00){} //wartet bis Byte gesendet
        break;
...

man soll immer mit 512Byte Blöcken arbeiten, da das ganze Speicher in 
sogenannte "pages" unterteilt ist.


Ich habe noch ein Verdacht,dass vor dem Screiben in den ROM die Daten 
dort erstmal gelöscht werden sollen. Also vor dem FEECON=0x02; muss eine 
FEECON=0x05; ausgeführt werden.

Du musst unbedingt darauf achten, welche page du löschst, weil dort 
eventuell noch dein Programmcode befinden kann, deshalt habe ich dir 
oben vorgeschlagen die Speicheradresse 0x87600 zu nehmen.

So...das wäre dann der grobe Überblick, bei weiteren Problemen oder 
Feinheiten frag mich einfach.


mfg Wadim

Autor: patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das hier soll ein Programm, das gut funktioniert aber was dieses 
Programm macht ist noch nicht was ich haben möchte.

*********************************************************************/
#include <ADuC7026.h>
#define PROTECT 0

extern int write (int file, char * ptr, int len);  // Function used to 
write string
void delay (int length);
void erase_page(unsigned short int addr);
void save(unsigned short int addr, unsigned char data);
void protect_page(unsigned int addr);
unsigned short load(unsigned short int addr);
unsigned short SingleVerify(unsigned short int addr, unsigned char 
data);
void senddata(short);
char hex2ascii(char);
unsigned char ERROR;
unsigned int status, uiTest, uiTest1, uiTest2;
unsigned short ucVerifyTest = 0;

unsigned int * data_ptr;
int main(void)
{
  unsigned char count = 0;
  unsigned int i = 0;
  char output[7] = "Error\n";
  ERROR = 0;

  GP1CON = 0x011;           // Setup tx & rx pins on P1.0 and P1.1

   // Start setting up UART at 9600bps
  COMCON0 = 0x80;        // Setting DLAB
  COMDIV0 = 0x88;        // updated for rev H
     COMDIV1 = 0x00;
     COMCON0 = 0x07;        // Clearing DLAB

  GP4DAT = 0x04000000;    // configure P4.2 as output
  FEEMOD = 0x8;        // bit 3 should be set to allow erase/write 
command
  data_ptr = (unsigned int *)0x00080448;
  uiTest = *data_ptr;
  delay(20);
  data_ptr++;
  uiTest1 = *data_ptr;
    delay(20);
    data_ptr++;

  uiTest2 = *data_ptr;
    delay(20);
if (PROTECT){          // if it is not protected yet

  erase_page(0xF000);        // erase page 120

  for (i=0;i<10;i++) {
    count ++;        // save numbers
      save(0xF000+2*i, count);
  }

  for (i=0;i<10;i++){      // Output Data
       senddata (load(0xF000+2*i));
  }

  protect_page(0xBFFFFFFF);   // protect pages
  RSTSTA = 0x02;         // software reset
}
else{
    erase_page(0xE000);        // erase page 120
  erase_page(0xF000);        // erase page 120

  erase_page(0xF200);        // erase page 121
  erase_page(0xF400);        // erase page 122

  count = 0xA;

  if (ERROR){
    write(0,output,7);    // Output Error message
  }
  else{
    for (i=0;i<10;i++){       // Save data
      save(0xE000+2*i, 0x77);

    }

    for (i=0;i<10;i++){       // Save data
      save(0xF000+2*i, count);
      count --;
    }
    for (i=0;i<10;i++) {
    count ++;        // save numbers
      save(0xF200+2*i, 0x55);
    }
    for (i=0;i<10;i++) {
    count ++;        // save numbers
      save(0xF400+2*i, 0xAA);
    }

    for (i=0;i<10;i++) {
    count ++;        // save numbers
      save(0xF300+2*i, count);
    }
     for (i=0;i<10;i++){           // Output Data
        senddata (load(0xE000+2*i));
    }

    for (i=0;i<10;i++){           // Output Data
          senddata (load(0xF000+2*i));
    }
    for (i=0;i<10;i++){      // Output Data
     senddata (load(0xF400+2*i));
    }
  }
  ucVerifyTest =  SingleVerify( 0xF300+4, 0x0003);
  protect_page(0xBFF00000);   // protect pages 120-123

  RSTSTA = 0x02;         // software reset
  while (1){
    GP4DAT ^= 0x00040000;    // complement P4.2
    delay(100000);
  }

  }

  return 0;
}

void delay (int length) {    // delay
  while (length >= 0)
      length--;
}

void protect_page(unsigned int addr){
  FEEADR = 0x1234;           // Key
  FEEDAT = 0xA5A5;          // Key
  FEEPRO = addr;
  FEEMOD = 0x48;
  FEECON = 0x0C;
  status = FEESTA&0x03;
  while (!(status)) status = FEESTA&0x03;
  if ((status&0x02)==0x02) //ERROR = 1;
  return;                // return
}


unsigned short load(unsigned short int addr){
  FEEADR = addr;
  FEECON = 0x01;        // single read command
  status = FEESTA&0x03;
  while (!(status)) status = FEESTA&0x03;
  if ((status&0x02)==0x02) ERROR = 1;
  return (FEEDAT);
}


void save(unsigned short int addr, unsigned char data){
  FEEADR = addr;        // set data address
  FEEDAT = data;        // set data value
  FEECON = 0x02;        // single Write command
  status = FEESTA&0x03;
  while (!(status)) status = FEESTA&0x03;
  if ((status&0x02)==0x02) ERROR = 1;
  return;
}

unsigned short SingleVerify(unsigned short int addr, unsigned char 
data){
  FEEADR = addr;        // set data address
  FEEDAT = data;        // set data value
  FEECON = 0x04;        // single verify command
  status = FEESTA&0x03;
  while (!(status)) status = FEESTA&0x03;
  if ((status&0x02)==0x02) ERROR = 1;
  return (status);
}

void erase_page(unsigned short int addr){
  FEEADR = addr;        // set data address
  FEECON = 0x05;        // erase page command
  status = FEESTA&0x03;
  while (!(status)) status = FEESTA&0x03;
  if ((status&0x02)==0x02) ERROR = 1;
   return;
}

void senddata(short to_send){
  while(!(0x020==(COMSTA0 & 0x020))){}
    COMTX = 0x0A;            // output LF
  while(!(0x020==(COMSTA0 & 0x020))){}
    COMTX = 0x0D;            // output CR
  while(!(0x020==(COMSTA0 & 0x020))){}
    COMTX = hex2ascii ((to_send >> 8) & 0x0F);
  while(!(0x020==(COMSTA0 & 0x020))){}
    COMTX = hex2ascii ((to_send >> 4) & 0x0F);
  while(!(0x020==(COMSTA0 & 0x020))){}
    COMTX = hex2ascii (to_send & 0x0F);
}


char hex2ascii(char toconv){
  if (toconv<0x0A) toconv += 0x30;
  else toconv += 0x37;
  return (toconv);
}

Autor: patrick (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Leute,
ich habe bis jetzt das gewünschte Ergebnis noch nicht erzielen können 
obwohl es einfach scheint.
Ich habe zuerst ein Problem mit einem Interuppt (external interuppt). Er 
wird durch eine Taste eingelöst und ich möchte es anwenden um das 
Speichern der Werte im EEPROM zu bewirken.

Das Speichern der Werte klappt auch nur halbs Weg
wenn ich etwas speichere, bekomme ich beim Lesen nur die 4 letzten 
Charater.

kann jemand mir sagen wie ich es besser hinbekommen kann.

Autor: patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo zusammen,
ich habe schon gefunden wie ich ein Wert im EEPROM speichern kann. Aber 
kaum löst man ein Problem,taucht ein neues auf. Ich merke jetzt dass der 
EEPROM-Register nur 16bit groß ist und die Wert, die ich speichern 
möchte 24bit codiert sind. Also ich bekomme nur die 16bit wieder beim 
Lesen.
Kamm man mir sagen wie ich das lösen kann.

Danke!!

mfg

pat....

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.