mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik EEPROM Uart LCD


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

Bewertung
0 lesenswert
nicht lesenswert
Hallo
habe Probleme mit dem EEPROM und wahrscheinlich dem Uart.
Ich möchte die vom Uart geschickten Zeichen im EEPROM speichern. Dies 
geschieht im Uart Interrupt Receive.
Die im EEPROM abgespeicherten Zeichen möchte ich dann lesen und (als 
Kontrolle für den korrekten Empfang) wieder auf einem Display ausgeben 
(Passiert ebenfalls noch im Uart Interrupt Receive).


Wie sich zeigt funktioniert es nicht korrekt.
Schicke ich z.B. vom PC die Zeichen :
12345678901234567890
so werden auf dem LCD nur die Zeichen 123970 angezeigt.


Die Funktionen zum EEPROM schreiben und Lesen haben ich dem Tutorium 
entnommen.
Woran kann es liegen. Hängt es vielleicht damit zusammen, dass einfach 
nicht alle Zeichen vom Mikrocontroller empfangen bzw. verarbeitet werden 
können. Oder ist mein LCD zu langsam? Ich verwende das LCD204B LED von 
Reichelt.
Wie müsste ich mein Programm umändern?

Quelltext ist angehängt
ATMega32, 11MHz

Autor: Knut Ballhause (Firma: TravelRec.) (travelrec) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Denke daran, Daß das EEPROM 4ms Zeit für das Speichern von 1 Byte 
benötigt. Wahrscheinlich ist Deine Baudrate zu hoch. Wartest Du in der 
Schreibroutine auf das Ende des eventuell gerade laufenden 
Schreibzyklusses?

Autor: Kulli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hi
ja ich warte auf auf das Ende des Schreibzyklusses

EEPROM_write:
    sbic    EECR, EEWE                  ; prüfe ob der letzte 
Schreibvorgang beendet ist
    rjmp    EEPROM_write                ; wenn nein, nochmal prüfen

Autor: Kulli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann keiner helfen?

Autor: Knut Ballhause (Firma: TravelRec.) (travelrec) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie hoch ist die Baudrate des UARTs?

Autor: Kulli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Baud=9600

Autor: Knut Ballhause (Firma: TravelRec.) (travelrec) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Macht knapp ein Byte pro Millisekunde - das schaffst Du nicht im EEPROM 
wegzuspeichern!

Autor: Kulli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das heißt was? Was muss ich machen und wo?

Autor: Kulli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann mir jemandhelfen?

Autor: Wasweissich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das heisst Du musst das Schreiben in das EEPROM aus der 
RX-Interrupt-Routine herausnehmen. Am besten schreibst Du die Daten 
erstmal in eine (Ring-)buffer.
Grundsätzlich ist es sehr gut zu überlegen ob solche langen 
Programmteile im Interrupt stehen sollten. Eher nicht.

Dann schreibst Du die Daten im Hauptprogramm. Während Du auf den 
Abschluss des Schreibvorganges wartest, kann der RX-Int dann weiterhin 
zuschlagen.
Verstanden?

Autor: fubu1000 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,
vorausgesetzt, du hast ein selbstgeschriebenes Programm am PC, welches 
Zeichen ausgibt!
Machst es in einem billig Protokoll:
z.B. wenn TX vom Pc senden will schickt es ein ACK, z.B. 0xAA.
Wenn der uC gerade nix zu tun hat schickt er ein, z.B. 0xBB zurück.
Dann kommen die Daten, die du im, ich hoffe ich irre mich jetzt nicht,
UDR-Register empfängst. Nach Ende des Empfangs sendest du z.B. ein 0xCC 
an den PC, damit das Proggi aufm PC wartet.
Dann kommt die LCD Ausgabe, oder sonstwas und dann sendest du z.B. ein 
0xDD an den PC, damit dein Proggi weiss er kann neues Zeichen senden.

Falls du z.B. Hyperterminal benutzt und weisst wieviel Daten kommen 
werden, würde ich diese im RAM speichern, ausserdem Variable hochzählen, 
wenn max. errreicht, aufm LCD Zeichen ausgeben.


Gruss fubu.

Autor: Kulli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo
danke für die Antworten.
Die Variante von fubu fällt jedoch aus, da die Daten später nicht vom PC 
gesendet werden und ich auch nicht entscheiden kann ein bestimmtes 
Zeichen bei  Bereitschaft ect zu senden.

Zu der Sache mit dem Ring-Buffer:
Gibt es hierfür evt. schon eine fertige Routine? Da es sich hierbei nur 
um ein Teilstück in einem größerem Projekt handelt, würde es mich 
freuen, wenn mir jemand dabei behilflich sein kann.
Wie würde das mit dem Ring-Buffer denn in etwa in Assembler aussehen?
Muss ich da den rol-Befehl nutzen?

Autor: Stephan Henning (stephan-)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
stelle Dir den Ringbuffer wie die Rotation des Akkus über Carry vor.
Nur nicht mit Bits sondern mit Bytes.
Und das was sonst ins Carry geht, geht dann eben in den EEPROM.

Autor: Kulli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi
habe jetzt schon studenlang im Netz nach Assembler-Routinen für 
Ring-Buffern gesucht. Leider ohne Erfolg.
Es wäre nett wenn mir jemand evt. kleinere Code-Snipsel zukommen lassen 
kann. Da ich absolut nicht weiss wie man das mit den Ring-Buffern 
realisieren kann. Bin auch noch nicht soooo bewandert in Assembler.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kulli wrote:
> Hi
> habe jetzt schon studenlang im Netz nach Assembler-Routinen für
> Ring-Buffern gesucht. Leider ohne Erfolg.

Dann: selber schreiben. Dabei lernst du sowieso mehr, als wenn
du nur fertige Routinen abkupferst.

> Es wäre nett wenn mir jemand evt. kleinere Code-Snipsel zukommen lassen
> kann. Da ich absolut nicht weiss wie man das mit den Ring-Buffern
> realisieren kann.

Hast du schon tausende male benutzt.
Wenn du grade an was arbeitest und jemand kommt zu dir ins Zimmer
und will dir was mitteilen, dann schreibst du das erst mal auf
und siehst es dir erst dann genau an, wenn Zeit dazu ist.

Ein Ringbuffer ist nichts anderes als eine Speicherfläche
in der die Daten erst mal landen. Rungbuffer heist er deswegen,
weil er logisch zu einem Ring zusammengeklebt wird. Ist man
am Ende der Speicherfläche angelangt, dann beginnt man ganz
einfach wieder vorne zu schreiben. So wie auf einem Papierstreifen
den man zu einem Ring zusammenklebt und einfach drauflosschreibt
und dabei das was vorher dort stand einfach überschreibt.

Du musst dir 2 Dinge in Variablen merken:
Wo darf das nächste Zeichen geschrieben werden
Von wo ist das letzte Zeichen gelesen worden

  Das sei deine Speicherfläche

    +---+---+---+---+---+---+---+---+
    |   |   |   |   |   |   |   |   |
    +---+---+---+---+---+---+---+---+

und jetzt das ganze mit den Schreib/Lesezeigern

    +---+---+---+---+---+---+---+---+
    |   |   |   |   |   |   |   |   |
    +---+---+---+---+---+---+---+---+
     ^^
     ||
     |+----------------+
     |                 |
   Lesen            Schreiben

Wenn jetzt ein Text zwischengespeichert werden muss, dann wandert
der erst mal in den Ringbuffer. Zb. der Text "abc"

    +---+---+---+---+---+---+---+---+
    | a | b | c |   |   |   |   |   |
    +---+---+---+---+---+---+---+---+
     ^             ^
     |             |
     |             +---+
     |                 |
   Lesen            Schreiben

Jetzt nehmen wir mal an, dein µC hat keine Zeit den Text zu bearbeitn
aber in der Zwischenzeit kommt ein neuer Text herein: 1 2

Diese Zeichen wandern ebenfalls in den Ringbuffer

    +---+---+---+---+---+---+---+---+
    | a | b | c | 1 | 2 |   |   |   |
    +---+---+---+---+---+---+---+---+
     ^                    ^
     |                    |
     |                 +--+
     |                 |
   Lesen            Schreiben

Dein µC hat jetzt endlich Zeit und beginnt sich das erste Zeichen aus
dem Ringbuffer zu holen: a

    +---+---+---+---+---+---+---+---+
    | a | b | c | 1 | 2 |   |   |   |
    +---+---+---+---+---+---+---+---+
          ^               ^
          |               |
     +----+            +--+
     |                 |
   Lesen            Schreiben


Er holt sich das nächste Zeichen: b

    +---+---+---+---+---+---+---+---+
    | a | b | c | 1 | 2 |   |   |   |
    +---+---+---+---+---+---+---+---+
              ^           ^
              |           |
     +--------+        +--+
     |                 |
   Lesen            Schreiben

und dann ist er erst mal beschäftigt. In der Zwischenzeit trifft
weiterer Text ein: defg
Auch der wird erst mal im Ringbuffer abgelegt

    +---+---+---+---+---+---+---+---+
    | g | b | c | 1 | 2 | d | e | f |
    +---+---+---+---+---+---+---+---+
      ^       ^
      +----------------+
     +--------+        |
     |                 |
   Lesen            Schreiben

Beachte: nach f ist die Speicherfläche zu Ende, also wird das noch
eingetroffene g ganz am Anfang geschrieben. Ist ja auch kein
Problem, das a das vorher dort stand wurde schon verarbeitet.

Dein µC hat jetzt wieder Zeit und widmet sich den nächsten
Zeichen aus dem Ringbuffer: c

    +---+---+---+---+---+---+---+---+
    | g | b | c | 1 | 2 | d | e | f |
    +---+---+---+---+---+---+---+---+
      ^           ^
      +----------------+
     +------------+    |
     |                 |
   Lesen            Schreiben

und noch eins: 1

    +---+---+---+---+---+---+---+---+
    | g | b | c | 1 | 2 | d | e | f |
    +---+---+---+---+---+---+---+---+
      ^               ^
      +----------------+
     +----------------+|
     |                 |
   Lesen            Schreiben


Aber jetzt dauerts wieder in der Bearbeitung. In der Zwischenzeit
kommt das nächste über die Schnittstelle: A

    +---+---+---+---+---+---+---+---+
    | g | A | c | 1 | 2 | d | e | f |
    +---+---+---+---+---+---+---+---+
          ^           ^
          +------------+
     +----------------+|
     |                 |
   Lesen            Schreiben

usw. usw. Aufpassen muss man eigentlich nur, wenn der Ringbuffer
dann tatsächlich voll wird. Wenn in der jetzigen Situation 3 Zeichen
eintrudeln, dann gibt es ein Problem.


Viel Spass bei der Implementierung!

Autor: Stephan Henning (stephan-)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl Heinz,
du bist eine Sonne.....

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Stephan Henning wrote:
> Karl Heinz,
> du bist eine Sonne.....

Wenn möglich erkläre ich ihm lieber das Prinzip und lasse
ihn selbst an einer Implementierung arbeiten. Das ist zwar
für mich mehr Aufwand aber wenn ers dann durchzieht hat er
mehr davon als wenn ich ihm eine fertige Routine präsentiere.
Erfahrungsgemäß wird die nämlich einfach so übernommen ohne
zu verstehen was da eigentlich abgeht und wie's funktioniert.
Bei Problemen steht er dann da und weiß erst recht nicht wo
hinten und vorne ist.

Viele Algorithmen in der Programmierung sind eigentlich
unglaublich einfach. Wir benutzen sie jeden Tag im
täglichen Leben ohne uns dessen bewusst zu sein.

(Und ausserdem hasse ich nichts mehr als Leute die sich
stolz im Bekanntenkreis mit ihren Programmierkünsten
präsentieren und in Wirklichkeit keinen blassen Schimmer
davon haben, was sie da eigentlich gemacht haben. Mit
'Malen nach Zahlen' kann man mich nicht wirklich beeindrucken)

Autor: ... ... (docean) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wau nette Erklärung zum Ringbuffer...

hier mal eine feritge UART Lib...
http://homepage.hispeed.ch/peterfleury/avr-softwar...
(und LCD Lib)

Autor: Kulli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hi
habs jetzt mal versucht selber zu schreiben.
Könnt ihr es kontrollieren? Bin mir nicht sicher wie man die Position 
des letzten Bytes abfragen kann.

so siehts aus:

.dseg
.equ  L_FIFO  =  128
FIFO_Data:  .byte  L_FIFO


init_FIFO:
    ldi XL,low(FIFO_Data)         ; read
    ldi XH,high(FIFO_Data)
    ldi YL,low(FIFO_Data)         ; write
    ldi YH,high(FIFO_Data)
ret


write_fifo:

    push temp1                ; temp auf dem Stack sichern
    in temp1, sreg            ; SREG sichern
    push temp1
    push temp2

    in temp1, UDR             ; UART Daten lesen
    st Y+, temp1

    ld temp2, Y
    cpi temp2, L_FIFO         ; Ende des Ringpuffers erreicht?
    brne no_reset_pointerY
    ldi YL,low(FIFO_Data)
    ldi YH,high(FIFO_Data)

  no_reset_pointerY:
   pop temp2
   pop temp1
   out sreg, temp1            ; SREG wiederherstellen
   pop temp1                 ; temp wiederherstellen

ret


read_fifo:
  push temp2
  ld r16, X+

  ld temp2, X
  cpi temp2, L_FIFO      ; Ende des Ringpuffers erreicht?
  brne no_reset_pointerX
  ldi XL,low(FIFO_Data)
  ldi XH,high(FIFO_Data)

  no_reset_pointerX:
  pop temp2
ret

Autor: Spess53 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi


>    ld temp2, Y ?????????????

Wenn schon, dann 'mov temp2,XL'.

Wenn man eine 2er-Potenz als Puffergrösse und eine günstige Stelle im 
RAM für den Puffer wählt kann man die Prüfung des Pufferendes durch eine 
AND-Operation ersetzen:

   .dseg
   .org $0000

Puffer:   .db 128


   .cseg

.....
   clr XL             ; Pointer initialisieren
   clr XH

.....

   ld temp2,X+
   andi XL,0b01111111 ; XL wird bei 128 wieder 0

MfG Spess

Autor: Kulli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bei mir fängt der RAM erst ab $0060 an. Wie kann ich nun auf das Ende 
des Pufferendes Überprüfen?

Autor: TheMason (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@karl heinz

echt schön beschrieben :-)
wunnerbar !

Autor: Hannes Lux (hannes)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kulli wrote:
> Bei mir fängt der RAM erst ab $0060 an. Wie kann ich nun auf das Ende
> des Pufferendes Überprüfen?

Im Falle des Y-Pointers:

.def buffersize=32

.dseg
.org sram_start
buffer:  .byte 32

.cseg

;...

 st y+,tmp
 cpi yl,buffer+buffersize
 brne weg_hier
 ldi yl,low(buffer)
 ldi xh,high(buffer)
weg_hier:

...

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

Bewertung
0 lesenswert
nicht lesenswert
Hallo danke an alle, nun funktioniert es.
Auch nochmal von mir ein Dank an Karl-Heinz.

Hat ja lange genug gedauert. Aber im Endeffekt ist es wirklich nicht 
schwer. Wie gesagt, das kommt wenn man nicht viel Ahnung in Assembler 
hat. Kann man das Ganze eigentlich auch mit nur einem Pointer 
realisieren?


@Karl-Heinz
Ich hatte im Netz ja nur nach Ring-Buffern geschaut, um überhaupt 
irgendetwas zu dem Prinzip zu finden. Selbst wenn ich fertige Routinen 
nutze, versuche ich schon diese nachzuvollziehen.

>Und ausserdem hasse ich nichts mehr als Leute die sich stolz im >Bekanntenkreis 
mit ihren Programmierkünsten präsentieren und in Wirklichkeit >keinen blassen 
Schimmer davon haben, was sie da eigentlich gemacht haben.

-->Das wird bei mir noch dauern. Bis ich das Projekt endlich fertig 
habe, kanns noch ne Weile dauern ;-)

Also nochmal vielen Dank

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.