Daten im internen EEPROM des AT89C5131 ablegen

Matze Gast #3203706
Lesenswert?
• ▲
▼ 
Hallo zusammen,

ich versuche in einen Einstellwert nachdem er eingestellt wurde, in das 
interne EEPROM des AT89C5131 abzulegen. Dazu habe ich folgendes 
Unterprogramm:

1
eeprom_speichern:

2
    mov  dptr,#00      ;Anfangsadresse EEPROM

3
waitEEPR1:  

4
    mov  a,eecon

5
    anl  a,#01h

6
    jnz  waitEEPR1    ;warten bis bereit

7
    

8
    clr  ea          ; Interrupts sperren

9
    mov  eecon,#02h    ;EEprom auswählen  

10
    mov a,hysterese  

11
    movx  @dptr,a      ;im EEPROM ablegen

12
    clr a

13
    mov  eecon,#0      ;nicht mehr auf EEPROM zugreifen

14
    setb  ea          ;Interupts wieder freigeben

15
  

16
ret


Zum aulesen habe ich folgendes Unterprogramm:

1
eeprom_lesen:  

2
    mov  dptr,#00      ;Anfangsadresse EEPROM

3
waitEEPR2:  

4
    mov  a,eecon

5
    anl  a,#01h

6
    jnz  waitEEPR2    ;warten bis bereit

7
    clr  ea          ; Interrupts sperren

8
    

9
    mov  r3,#255      ;Zähler Byte

10
    mov  eecon,#02h    ;EEprom auswählen    

11
    movx  a,@dptr      ;Wert holen

12
    mov  eecon,#0      ;nicht mehr auf EEPROM zugreifen

13
    setb  ea          ;Interupts wieder freigeben

14
    mov   hysterese,a

15


16
ret


Das Programm zum auslesen gibt mir den Wert 255 zurück. Laut 
Buffer-Ansicht des EEPROMs würde das ja passen, dort ist ja FF 
hinterlegt. Hat jemand eine Idee, warum das unterprogramm nicht 
abspeichert?
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Matze Gast #3541628
Lesenswert?
• ▲
▼ 
So, ich hab mich nochmal mit der Thematik beschäftigt, so funktioniert 
es nun:


1
eeprom_speichern:

2
    clr  ea          ; Interrupts sperren

3
    mov  eecon,#02h

4
    mov  dptr,#0001h      ;Anfangsadresse EEPROM

5
    

6
    mov a,hysterese  

7
    movx  @dptr,a      ; Daten in Column-Latch speichern

8
    

9
    

10
    mov eecon, #054h    ; Daten von Column-Lach in Eeprom speichern

11
    mov eecon, #0A4h

12
waitEEPR1:    

13
    mov  a,eecon

14
    anl  a,#01h

15
    jnz  waitEEPR1    ;warten bis bereit

16
    setb  ea          ;Interupts wieder freigeben

17
    

18
    

19
  

20
ret
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Bernhard S. #3579018
Lesenswert?
• ▲
▼ 
Schön, dass Du es hinbekommen hast (und auch hier schreibst).
Falls das jemand in C braucht:
1
#include <typedefs.h> // uC8 => unsigned char und so weiter...

2
#include <at89c5131.h>

3


4
uC8 EEPROM_rd(uC8 xdata *address)

5
{

6
  // Auf EEPROM umschalten, einzelnes Byte aus EEPROM lesen und im 

7
  // RAM (IDATA, nicht XDATA) lagern,

8
  // dann auf XDATA zurückschalten und von IDATA nach XDATA zurückgeben

9
  uC8 val;        // IDATA

10
  bit ea_save = EA;             // Interrupts speichern

11
  EA = 0;        // Interrupts ausschalten

12
  EECON = 0x02;      // XDATA > EEPROM schalten

13
  val   = *address;             // EEPROM > IDATA lesen

14
  EECON = 0x00;      // EEPROM > XDATA schalten

15
  EA = ea_save;      // Interrupts wiederherstellen

16
  return (val);      // IDATA > XDATA zurückgeben

17
}

18


19
void EEPROM_wr(uC8 xdata *address, uC8 val)

20
{

21
  bit ea_save = EA;           // Interruptstatus zwischenspeichern

22
  EA = 0;        // und ausschalten

23
  //WD_ACK();      // falls Watchdog verwendet wird, vorher ruhigstellen

24
  EECON = 0x02;      // auf EEPROM mappen

25
  *address = val;            // Pointer auf EEPROM beschreiben

26
  EECON = 0x52;      // Schreibsequenz einleiten (Datenblatt S.40)

27
  EECON = 0xA2;      // Schreibsequenz vollenden

28
  while (EECON & 0x01);         // warten bis EEPROM zu Ende geschrieben wurde...

29
  EECON = 0x00;             // EEPROM > XDATA schalten

30
  EA = ea_save;             // Interruptstatus wiederherstellen

31
}

32


33
void EEPROM_wr_block(uC8 xdata *address, uC8 data *daten, uC8 length)

34
{

35
  uC8 k;      // Zähler für Anzahl Datenbytes

36
  bit ea_save = EA;           // Interruptstatus zwischenspeichern

37
  EA = 0;        // und ausschalten

38
  EECON = 0x02;      // auf EEPROM mappen

39
  for (k=0; k < length; k++)

40
  {

41
    *address = daten[k];  // Pointer auf EEPROM beschreiben

42
    EECON = 0x52;    // Schreibsequenz einleiten (nicht wie Datenblatt S.40)

43
    EECON = 0xA2;    // Schreibsequenz vollenden

44
    while (EECON & 0x01); // warten bis EEPROM zuende geschrieben wurde...

45
      *address++;           // nächsten Wert vorbereiten

46
  }

47
  EECON = 0x00;     // EEPROM > XDATA schalten

48
  EA = ea_save;     // Interruptstatus wiederherstellen

49
}

50


51
void EEPROM_rd_block(uC8 xdata *address, uC8 data *daten, uC8 length)

52
{

53
  // Auf EEPROM umschalten, einzelnes Byte aus EEPROM lesen und im 

54
  // RAM (IDATA, nicht XDATA) lagern,

55
  // dann auf XDATA zurückschalten und von IDATA nach XDATA zurückgeben

56
  uC8 k;        // Zähler für Anzahl

57
  bit ea_save = EA;             // Interrupts speichern

58
  EA = 0;        // Interrupts ausschalten

59
  EECON = 0x02;      // XDATA > EEPROM schalten

60
  for (k=0; k < length; k++)

61
  {

62
    daten[k] = *address;  // Pointer auf EEPROM lesen

63
      *address++;           // nächsten Wert vorbereiten

64
  }

65
  EECON = 0x00;      // EEPROM > XDATA schalten

66
  EA = ea_save;      // Interrupts wiederherstellen

67
  return;      

68
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren