mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik atmega8 Flip flop


Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,
Ich hbae mir folgende asm zusammengestrikt.

Eigentlich wollte ich einen Tasten entprellten Flip flop, der den 
Letzten zustand in das Eprom schreibt und nach erneuten Spannungszufuhr 
das Eprom ausliest und die letzte Benutzte einstellungen wieder 
herstellt.

ich Muß gestehen das ich absoluter trittbrett fahrer bin.

Und leider noch kein passendes buch für trittbrettfahrer gefunden habe

So Habe ich mich durch die Webseite etwas schlau gemacht mein Wissen 
über der programierung reit leider nicht aus um das umsetzen zu können.

Vileicht kann hier jemand helfen?
.include "m8def.inc"
 
.def iwr0      = r1
.def iwr1      = r2
 
.def key_old   = r3
.def key_state = r4
.def key_press = r5
 
.def temp1     = r17
;.def sreg_save = r18

 
.equ key_pin   = PINB
.equ key_port  = PORTB
.equ key_ddr   = DDRB
 
.def leds      = r16
.equ led_port  = PORTD
.equ led_ddr   = DDRD
 
.org 0x0000
;rcall   EEPROM_read 
    rjmp    init
 
.org OVF0addr
    rjmp    timer_overflow0
 ;rcall   EEPROM_read
timer_overflow0:               ; Timer Overflow Interrupt
 
    push    r0                 ; temporäre Register sichern
    in      r0, SREG
    push    r0
    push    iwr0
    push    iwr1
 
get8key:                       ;/old      state     iwr1      iwr0
    mov     iwr0, key_old      ;00110011  10101010            00110011
    in      key_old, key_pin   ;11110000
    eor     iwr0, key_old      ;                              11000011
    com     key_old            ;00001111
    mov     iwr1, key_state    ;                    10101010
    or      key_state, iwr0    ;          11101011
    and     iwr0, key_old      ;                              00000011
    eor     key_state, iwr0    ;          11101000
    and     iwr1, iwr0         ;                    00000010
    or      key_press, iwr1    ; gedrückte Taste merken
;
;
    pop     iwr1               ; Register wiederherstellen
    pop     iwr0
    pop     r0
    out     SREG, r0
    pop     r0
    reti
 
 
init:
    ldi      temp1, HIGH(RAMEND)
    out      SPH, temp1
    ldi      temp1, LOW(RAMEND)     ; Stackpointer initialisieren
    out      SPL, temp1
 
    ldi      temp1, 0xFF
    out      led_ddr, temp1
 
    ldi      temp1, 0xFF            ; Tasten sind auf Eingang
    out      key_port, temp1        ; Pullup Widerstände ein
 
    ldi      temp1, 1<<CS02 | 1<<CS00   ; Timer mit Vorteiler 1024
    out      TCCR0, temp1
    ldi      temp1, 1<<TOIE0            ; Timer Overflow Interrupt einrichten
    out      TIMSK, temp1
 
    clr      key_old                ; die Register für die Tastenauswertung im
    clr      key_state              ; Timer Interrupt initialisieren
    clr      key_press
 
    sei                             ; und los gehts: Timer frei
 
    ldi      leds, 0xFF
    out      led_port, leds
; EEprom ***
rcall   EEPROM_read                 ; Daten aus EEPROM lesen
;rcall   EEPROM_write                ; Byte im EEPROM speichern
    out     PORTD, leds
  ;EEprom

main:
    cli                             ; 
    mov      temp1, key_press       ; Einen ev. Tastendruck merken und ...
    clr      key_press              ; Tastendruck zurücksetzen
    sei
 
    cpi      temp1, 0               ; Tastendruck auswerten. Wenn eine von 8 Tasten
    breq     main                   ; gedrückt worden wäre, wäre ein entsprechendes
                                    ; Bit in key_press gesetzt gewesen
 ;rcall   EEPROM_write
   
   eor      leds, temp1            ; Die zur Taste gehörende Led umschalten
  rcall   EEPROM_write
    out      led_port, leds
;  rcall   EEPROM_write
    ;rjmp     main
;EEprom Lesen
;loop:   
 ;   rjmp loop
 
EEPROM_read:
    sbic    EECR,EEWE                   ; prüfe ob der vorherige Schreibzugriff
                                        ; beendet ist
    rjmp    EEPROM_read                 ; nein, nochmal prüfen
 
    out     EEARH, ZH                   ; Adresse laden
    out     EEARL, ZL    
    sbi     EECR, EERE                  ; Lesevorgang aktivieren
    in      r16, EEDR                   ; Daten in CPU Register kopieren
    ret

  rjmp    main

  ;rjmp    timer_overflow0
 ;Eprom Schreiben
EEPROM_write:
    sbic    EECR, EEWE                  ; prüfe ob der letzte Schreibvorgang beendet ist
    rjmp    EEPROM_write                ; wenn nein, nochmal prüfen
 
    out     EEARH, ZH                   ; Adresse schreiben
    out     EEARL, ZL                   ; 
    out     EEDR, leds               ; Daten  schreiben
    in      leds,sreg              ; SREG sichern
    cli                                 ; Interrupts sperren, die nächsten
                                        ; zwei Befehle dürfen NICHT
                                        ; unterbrochen werden
    sbi     EECR,EEMWE                  ; Schreiben vorbereiten
    sbi     EECR,EEWE                   ; Und los !
    ;out     sreg, r16            ; SREG wieder herstellen
    ;ret
 

; Daten im EEPROM definieren
;
.eseg
;
daten:
    .db     0b00000000
----------------
Gruß markus

: Bearbeitet durch Moderator
Autor: Flo (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Was erwartest du jetzt genau?
Gehts um Fehlersuche?
   Dann teil uns mit was nicht funktioniert.
Willst du ein komplettes Programm von irgendjemandem?
   Das wirst du höchstwahrscheinlich nicht bekommen.
Willst du weitere Infos über ein Gebiet, das du nicht verstehst?
   Dann stell deine Frage genauer.

Autor: Hc Zimmerer (mizch)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das Programm läuft so nicht.  Ist es das, was Du hören wolltest? 
Beispielsweise kehrt die Function EEPROM_write nie zurück (der 
abschließende 'ret' ist wegkommentiert).  Ähnlich wenn eine Taste 
gedrückt wird (angenommen die Tastenerkennung tut, was sie soll):  Das 
Programm läuft dann geradeaus in EEPROM_read hinein.  Das endet mit 
einem 'ret', der in die Wüste führt, da es dafür nie einen rcall gab. 
Auch hier gäbe es eine richtige Version, aber die ist wieder mal 
wegkommentiert.

Soviel fällt schon beim groben Drüberschauen auf.

Du könntest Dein Programm schon erst mal debuggen, denn das ist ein 
wesentlicher Teil des Programmierens, bevor Du so etwas Unfertiges 
anderen Leuten kommentarlos zum Drauf-rum-Kauen vorwirfst.

Autor: markus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Gut dann einmal etwas genauer

der Entprellte Flip flop Funktioniert.

Die daten Werden nicht in das Eprom geschrieben und auch nicht 
Ausgelesen

Wer kann den fehler finden und Korregieren?


Ich Brauche eine Beschreibung in Kurzform für Sämtliche Befehle die in 
ASM angewendet werden. Am Besten in Deutsch

Wie debuggt mann?

Ich habe da keine Ahnung. Wenn ich das alles wüste, dann Hätte ich nicht 
hier nachgefragt.

Habe mit Programieren absolut 0 erfahrung

Gruß markus

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

Bewertung
0 lesenswert
nicht lesenswert
markus schrieb:

> Ich Brauche eine Beschreibung in Kurzform für Sämtliche Befehle die in
> ASM angewendet werden. Am Besten in Deutsch

Die wirst du nicht kriegen.
Programmierung spielt sich nun mal im wesentlichen in englischer Sprache 
ab.

>
> Wie debuggt mann?
>
> Ich habe da keine Ahnung. Wenn ich das alles wüste, dann Hätte ich nicht
> hier nachgefragt.
>
> Habe mit Programieren absolut 0 erfahrung

Dann fang an, das Tutorial durchzuarbeiten.
http://www.mikrocontroller.net/articles/AVR-Tutorial

Autor: Martin Vogel (oldmax)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hi
Das Tutorial hätte ich dir auch empfohlen. Es ist in Deutsch und ich 
fand es sehr gut. Grad für die ersten Schritte bieten die Grundübungen 
doch eine gute Grundlage. Nun, eine Übersicht über Assemblerbefehle hast 
du z.B. in AVRStudio in der Hilfe. Auch wenn's denn englisch ist, viele 
Assemblerbefehle erklären sich selbst. LD ist ein Befehl zum Laden eines 
Registers. Meist folgt noch ein S oder I . Wenn mann sich also eine 
Leseart angewöhnt wie Ld = Load ST =Store, BRNE =Branch Not Equal 
(springe wenn nicht gleich) ist Assembler einfach. Die Begriffe sind im 
Tutorial erklärt, daher werd ich hier nicht weiterführen. Wichtig ist 
allerdings, das man in der Lage ist, seine Programme zu strukturieren. 
Manchmal hilft ein Blatt Papier, um die Struktur zu skizzieren. Dann 
werden die Programmteile ( unterprogramme ) deutlich. Auch kann man 
Kommentarzeilen in den Code einfügen, um ihm leserlich zu halten wie 
z.B.
;********************************
;*  Mein kleines Unterprogramm  *
;********************************
My_UP1: irgend
        ein
        Code
     RET
;********************************
Dann kann man auch noch nach einem halben Jahr sein Programm lesen und 
verfolgen.
Gruß oldmax

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Genau das ist mein Problem

Im Tutorial habe ich die programme auch her und versucht aus dem 8 
entprellte tasten und ebend EEprom Lesen und Schreiben Kombeniert.

Das bekomme ich einfach nicht hin entwerde bekomme ich das EEprom 
ausgelesen oder der taster Funktioniert geschweige denn die 
Sreibfunktion.

Die Informationen dazu wie die Drei Komponenten mit einander verbunden 
werden wird natürlich nicht´s erwähne.

das sollte doch für ein Programierer doch ein klax sein mal die Drei 
Komponenten mit einander zu verbinden.

Und im AVM Studio stehen nicht alle befehle drin. Ausgerechnet die 
befehle die mir Überhaupt nichts sagen fehelen natürlich gruß markus

PS ich würde mich freuen wenn das hier jemand zusammen basteln kann.

ich kann auch gerne noch einmal die kompletten getrennten Programme 
Posten.

Außerdem währe das alleine für den Tutorial eine Tolle Sache

1. At mega8 Sird mit Strom versorgt.
2. die Daten werden Ausgelesen und Am Port ausgegeben z.b. Port D
3. die Flip flop Schaltung Hier wird dann die Änderung der Bits Mit 
entprellte taster vorgenommen.
4. Die geänderten daten werden Überschrieben im Eprom

Das ist schon alles

Für mich nicht erreichbar

Für euch kein Problem!

Zumal die Programmteile nicht neu geschrieben werden müssen sie sind 
schon auf der Seite.

Das Alles muß nur mit einander verbunden werden

Gruß markus
2.

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

Bewertung
0 lesenswert
nicht lesenswert
Markus Andrzejewski schrieb:

> Die Informationen dazu wie die Drei Komponenten mit einander verbunden
> werden wird natürlich nicht´s erwähne.

Das ist auch in einem gewissen Sinne der falsche Ansatz.

Programmieren funktioniert nicht nach dem Muster
ich klau mir dort was
ich klau mir da was
dann schmiere ich mir noch ein wenig verbindenden Kitt dazwischen und 
das wars dann

Man kann schon Komponenten übernehmen. Aber das tut man, indem man die 
Idee, die dahintersteckt übernimmt. Und dazu muss man die Idee erst 
einmal verstanden haben.

Gerade auf Assemblerebene, muss man immer wieder die geklauten 
Komponenten an die real vorliegenden Gegebenheiten anpassen. Und ohne 
Verständnis dessen, was da eigentlich passiert und warum, ist das nun 
mal nicht oder nur sehr schwer möglich.

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

Bewertung
0 lesenswert
nicht lesenswert
Markus Andrzejewski schrieb:

> Außerdem währe das alleine für den Tutorial eine Tolle Sache

Nicht wirklich

> 1. At mega8 Sird mit Strom versorgt.
> 2. die Daten werden Ausgelesen und Am Port ausgegeben z.b. Port D
> 3. die Flip flop Schaltung Hier wird dann die Änderung der Bits Mit
> entprellte taster vorgenommen.
> 4. Die geänderten daten werden Überschrieben im Eprom

Wer das Tutorial von Anfang an durchgearbeitet hat, sollte damit 
eigentlich überhaupt keine Schwierigkeiten haben:
Eingänge auslesen ist in der ersten Übung drinnen
Dinge verknüpfen kommt etwas später (und so schwer ist ein Flip Flop, 
das von 2 Eingängen angesteuert wird dann auch wieder nicht. Das ist 
einfach nur ein Register: Ist Eingang A auf high, wird das Register auf 
1 gesetzt. Ist Eingang B auf 1 wird es wieder auf 0 gesetzt. Fertig)
Ausgänge setzen ist ebenfalls in der ersten Übung
Und den Inhalt eines Registers ins EEPROM schreiben bzw. am Anfang 
wieder aus dem EEPROM holen, nun ja, genau das ist ja auch Thema eines 
Kapitels im Tutorial.

Und noch ein Tip:
Da ein Flip Flop vorhanden ist, welches nur auf Signale von 2 Eingängen 
hört, ist Tastenprellen überhaupt kein Thema und muss gar nicht beachtet 
werden :-) Du hast dir in dem Bereich viel zu viel Arbeit gemacht.

Ohne die EEPROM Funktionalität würde ich mal über den Daumen peilen und 
sagen: Das Programm wird deutlich weniger als 30 Assembleranweisungen 
haben. Nach dem Initialisierungsteil eher mehr so in der Gegend 5 bis 10 
Anweisungen (wie gesagt: Ohne den EEPROM Teil)

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wenn das so einfach ist warum tut ihr euch dann alle so schwer eine 
Lösung hier zu veröffendlichen?

Ich Kriege das nicht hin.

Gruß Markus

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

Bewertung
1 lesenswert
nicht lesenswert
Markus Andrzejewski schrieb:
> Wenn das so einfach ist warum tut ihr euch dann alle so schwer eine
> Lösung hier zu veröffendlichen?
>
> Ich Kriege das nicht hin.

Weil DU es lernen sollst.
Ansonsten: Kauf dir einen Programmierer ein. Diejenigen die das alles 
von der Pieke auf gelernt haben, verdienen ihre Brötchen damit.

Wir helfen dir gerne, das zu lernen.
Wir helfen dir auch gerne Fehler in deinem Code auszumerzen.
Aber wir können auf den Tod nicht ausstehen, wenn jemand nicht gewillt 
es, das alles zu lernen sondern eine fertige Lösung präsentiert haben 
will.
Da kommt dann bei den Profis der Gedankengang "eigentlich verdiene ich 
mit genau solchen Dingen meine Brötchen" durch. Und da finanziere ich 
mir dann lieber selber 1 Tag Urlaub irgendwo, als dir zu helfen, mit 0 
Aufwand eine Prüfung zu bestehen (und genau danach klingt es nämlich: 
nach einer Schulaufgabe)

Und abgesehen vom EEPROM Teil:
Die Aufgabe ist NICHT schwer! Ganz und gar nicht.
2 Eingänge miteinander zu verknüpfen und mit dem Ergebnis einen Ausgang 
ansteuern. Alles was dazu nötig ist, findet sich in 2 von den ersten 
paar Kapitel. Namentlich: I/O, wie werden Pins ausgelesen bzw. Pins auf 
0 oder 1 gesetzt. Und dann noch: Wie mache ich eine Fallunterscheidung.
Und mehr braucht man nicht für ein µC-realisiertes Flip Flop, welches 
auf 2 Tasten hört und meinetwegen eine LED ansteuert.

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo karl,

Siehst du genau da hapert es Wie mann die Port Verändert habe ich 
Verstanden ist für mich auch ersichtlich. R16 in R17 umgeändert Läuft 
auch

Und mehr verstehe ich dann nicht

ich habe es leider nicht gelernt.

Gruß markus

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

Bewertung
0 lesenswert
nicht lesenswert
Markus Andrzejewski schrieb:

> ich habe es leider nicht gelernt.

Dann lerne es.
Genau dazu gibt es das Tutorial


Aber ok. Hier ist dein Stufenplan

Schreib ein Programm welches eine LED ausgehend von einer Taste
ansteuert.
Wenn die Taste gedrückt wird, leuchtet die LED. Lässt du die Taste
wieder los, leuchtet die LED nicht mehr. Die LED spiegelt also einfach
nur den Zustand der Taste wieder.

Nächste Stufe:
Jetzt soll die Taste die LED einfach nur einschalten. Grundstellung: LED
leuchtet nicht. Taste wird gedrückt -> LED leuchtet. Und auch dann wenn
ich die Taste los lasse, soll die LED weiterleuchten.

Nächste Stufe:
Diesmal das ganze in der umgekehrten Richtung. Die LED leuchtet eingangs 
und wenn ich eine Taste drücke, soll sie ausgehen.

Nächste Stufe:
Jetzt kommt eine 2te Taste ins Spiel
Die erste sorgt dafür, dass die LED angeht
Die zweite sorgt dafür, dass sie wieder ausgeht

Nächste Stufe:
Hey, das erste Teilziel ist ja bereits erreicht: Die beiden Tasten
bilden gemeinsam mit dem µC ein Flip-Flop!


Das alles kannst du mehr oder weniger erledigen, wenn du nur das erste 
Kapitel (das über I/O) im Tutorial durchgearbeitet und verstanden hast. 
OK. Vergleiche und bedingte Sprünge braucht man noch. Aber die sind 
nicht so schwer (und kommen auch irgendwo vor). Und zur Not kannst du 
auch fragen. Aber bitte gezielt fragen! "Ich hab im Register xyz einen 
Wert stehen. Wie kann ich feststellen ob der 0 ist?"

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich Habe mir ein buch gekauf, Allerdings wird dort eher das AVR Studio 
erklärt Muster beispiele hatt der Autor auf seine Webseite natürlich in 
HEX

Und in den Einzelheiten geht er nicht hinein. Da verweist er auf seine 
test Projekte die in hex sind.

Natürlich will ich es lernen ich brauche da noch Weitaus Komplezierteres 
und will erst einmal mit was einfaches Anfangen.

Habe auch Weiter experementiert die register verschoben oder angepast 
die Port´s angepast das funktioniert ja auch.

Und wenn ich jetzt Wieder den Quell text hochlade Dann habe ich wohl 
neue fehler eingebaut.

gruß markus

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

Bewertung
0 lesenswert
nicht lesenswert
Markus Andrzejewski schrieb:

> Habe auch Weiter experementiert die register verschoben oder angepast
> die Port´s angepast das funktioniert ja auch.


Noch mal.
Der Code ist für den Müll!

Viel zu kompliziert. Viel zu umfangreich.

Eine reine Flip-Flop Lösung (ohne den EEPROM Teil) liegt komplett bei 
deutlich unter 30 Zeilen. Die Hauptschleife, die die eigentliche Arbeit 
macht, hat lediglich 5 Anweisungen (das ist das komplette Flip-Flop!). 
Nicht mehr!

Das ganze Programm, inklusive Initialisierung, hat vielleicht 10 oder 15 
Anweisungen.
Du brauchst keinen Timer, du brauchst keine Tastenentprellung, gar 
nichts. Nur Eingänge abfragen, Ausgänge setzen und bedingte Sprünge.
Und insbesondere letzteres kann mit ersterem kombiniert werden: Ein 
bedingter Sprung, wenn ein Eingangspin einen bestimmten Wert (entweder 0 
oder 1) aufweist. Und das ist dann schon alles.

Dein Programm muss diese Logik implementieren
            +---------------------+
            | Eingänge & Ausgänge |
            |   konfiguriern      |
            | Pull Up einschalten |
            |   wenn notwendig    |
            +---------------------+
                       |
                       |
       +-------------->|
       |               v                  Ja
       |           Eingang A auf 1 ?   ----------+
       |               | Nein                    v
       |               |                  Ausgang auf 1
       |               |                         |
       |               |<------------------------+
       |               |
       |               v                  Ja
       |           Eingang B auf 1 ?   ----------+
       |               | Nein                    v
       |               |                  Ausgang auf 0
       |               |                         |
       |               |<------------------------+
       |               |
       +---------------+

Und du willst mir jetzt hoffentlich nicht weiter ernsthaft erzählen, 
dass das zu schwierig für dich ist.

Und wenn ich es recht bedenke, kommt alles was du dazu brauchst, im 
zweiten Kapitel im Tutorial (I/O) vor.

EEPROM ist dann eine eigene Geschichte. Aber bis hierher musst du es 
alleine schaffen.

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hier noch einmal eine neue Datei taster und eprom Auslesen
Setze ich "ret "
Wird das Eprom ausgelesen das funktioniert auch
allerdings funktionieren dann keine taster mehr

disnabel ich ret. Funktionieren die tasten zwar wieder aber das Eprom 
wird nicht ausgelesen.

Was fehlt denn hier?

Gruß Markus
.include "m8def.inc"
  ;daten laden
  .cseg
 
    ldi     r16, low(RAMEND)            ; Stackpointer initialisieren
    out     SPL, r16                    
    ldi     r16, high(RAMEND)
    out     SPH, r16                    
 
    ldi     r16, 0xFF
    out     DDRD, r16                   ; Port D Ausgang
 
    ldi     ZL,low(daten)               ; Z-Zeiger laden
    ldi     ZH,high(daten)
    rcall   EEPROM_read                 ; Daten aus EEPROM lesen
    out     PORTD, r16
 
;loop:   
 ;   rjmp loop
 
EEPROM_read:
    sbic    EECR,EEWE                   ; prüfe ob der vorherige Schreibzugriff
                                        ; beendet ist
    rjmp    EEPROM_read                 ; nein, nochmal prüfen
 
    out     EEARH, ZH                   ; Adresse laden
    out     EEARL, ZL    
    sbi     EECR, EERE                  ; Lesevorgang aktivieren
    in      r16, EEDR                   ; Daten in CPU Register kopieren
   ; ret
  ;?????
  rjmp taster

 
Taster:
  
  ldi r16, 0xFF
         out DDRD, r16     ; Alle Pins am Port B durch Ausgabe von 0xFF ins
                           ; Richtungsregister DDRB als Ausgang konfigurieren
         ldi r16, 0x00
         out DDRB, r16     ; Alle Pins am Port D durch Ausgabe von 0x00 ins
                           ; Richtungsregister DDRD als Eingang konfigurieren
 
         ldi r16, 0xFF     ; An allen Pins vom Port D die Pullup-Widerstände
         out PORTB, r16    ; aktivieren. Dies geht deshalb durch eine Ausgabe
                           ; nach PORTD, da ja der Port auf Eingang gestellt ist.
;loop:
         in r16, PINB      ; an Port D anliegende Werte (Taster) nach r16 einlesen
     
         out PORTD, r16    ; Inhalt von r16 an Port B ausgeben
         ;rjmp loop         ; Sprung zu "loop:" -> Endlosschleife 

     ; Daten im EEPROM definieren
.eseg
daten:
    .db     0b10101010

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

Bewertung
0 lesenswert
nicht lesenswert
EEPROM_read ist eín Unterprogram.
Ein Unterprgram wird benutzt indem man es mit einem rcall aufruft. Dann 
wird das Unterprogramm abgearbeitet, bis es auf einen ret stösst. Der 
ret sorgt dafür, das die Programmausführung an der Stelle fortgesetzt 
wird, an der der rcall erfolgte.

Also so
    |
    |
  Hauptlinie des Programms            +---> EEPROM_read:
    |                                 |         |
    |                                 |         |
  rcall EEPROM_read   ----------------+       Ausführungslinie des UP
      <---------------------------+             |
    |                             |             |
    |                             |            ret
   weiter gehts                   +-------------+
    |
    |
Mit dem rcall verzweigt die Programmausführung zu EEPROM_read. Dort wird 
weitergearbeitet. Bis dann irgendwann der ret kommt. Mit dem ret gehts 
zurück dorthin, von wo der rcall hergekommen ist. Und dort wird dann mit 
der Programmausführung wieder weiter gemacht.

Sinn der Sache ist es, dass EEPROM_read von mehr als einer Stelle im 
Programm aufgerufen werden kann, und jedesmal immer genau zu der Stelle 
zurückkehrt, von wo es aufgerufen wurde.


Und ach ja: Zuwiederhandlungen gegen dieses Schema, werden mit 
Programmabstürzen bzw. Nichtfunktionieren nicht unter 3 Stunden 
Fehlersuche geahndet.

: Bearbeitet durch Moderator
Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
gut das habe ich jetzt verstanden.

Also Habe ich diese befehle herrausgelöscht.
da ich sie ja eigentlich nicht brauche.
Das sieht dann So aus
.include "m8def.inc"
  ;daten laden
  .cseg
 
    ldi     r16, low(RAMEND)            ; Stackpointer initialisieren
    out     SPL, r16                    
    ldi     r16, high(RAMEND)
    out     SPH, r16                    
 
    ldi     r16, 0xFF
    out     DDRD, r16                   ; Port D Ausgang
 
    ldi     ZL,low(daten)               ; Z-Zeiger laden
    ldi     ZH,high(daten)
   
    sbic    EECR,EEWE                   ; prüfe ob der vorherige Schreibzugriff
                                        ; beendet ist
               
 
    out     EEARH, ZH                   ; Adresse laden
    out     EEARL, ZL    
    sbi     EECR, EERE                  ; Lesevorgang aktivieren
    in      r16, EEDR                   ; Daten in CPU Register kopieren
   out     PORTD, r16
  ;??????????????
  Und hier wieder das Gleiche Problem! Eprom wird nicht geladen, wenn nachfolgende zeilen Akteviert sind!
Was ist hier an dieser Stelle falsch?

Gruß markus
 
Taster:
  
  ldi r16, 0xFF
         out DDRD, r16     ; Alle Pins am Port B durch Ausgabe von 0xFF ins
                           ; Richtungsregister DDRB als Ausgang konfigurieren
         ldi r16, 0x00
         out DDRB, r16     ; Alle Pins am Port D durch Ausgabe von 0x00 ins
                           ; Richtungsregister DDRD als Eingang konfigurieren
 
         ldi r16, 0xFF     ; An allen Pins vom Port D die Pullup-Widerstände
         out PORTB, r16    ; aktivieren. Dies geht deshalb durch eine Ausgabe
                           ; nach PORTD, da ja der Port auf Eingang gestellt ist.
;loop:
         in r16, PINB      ; an Port D anliegende Werte (Taster) nach r16 einlesen
     
         out PORTD, r16    ; Inhalt von r16 an Port B ausgeben
         ;rjmp loop         ; Sprung zu "loop:" -> Endlosschleife 

   ; Daten im EEPROM definieren
.eseg
daten:
    .db     0b10101010

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

Bewertung
0 lesenswert
nicht lesenswert
Markus Andrzejewski schrieb:

>    out     PORTD, r16
>   ;??????????????
>   Und hier wieder das Gleiche Problem! Eprom wird nicht geladen, wenn
> nachfolgende zeilen Akteviert sind!

Und was denkst du, wie lange es dauert, bis dein Programm dann diese 
Stelle erreicht
         in r16, PINB      ; an Port D anliegende Werte (Taster) nach
r16 einlesen

         out PORTD, r16    ; Inhalt von r16 an Port B ausgeben
wo dann ein ganz anderer Wert an PORTD ausgegeben wird.

Mein Rat: nimm dir einen Bleistift und benutze ihn als Markierung 
welcher Befehl als nächster drann ist. Und dann spielst du Computer und 
gehst dein Programm durch. Befehl für Befehl, Anweisung für Anweisung

WEnn du das schon nicht selbst machen willst, dann benutze wenigstens 
den Simulator und geh dein Programm in Einzelschritten durch.
Bei jedem Befehl überlegen: Welche Voraussetzungen gibt es? Was erwarte 
ich, dass passiert?

: Bearbeitet durch Moderator
Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also Muß ich sehrwarscheinlich 2 Register benutzen
mit or sollte es funktionieren
Nur wie bekomme ich r16 und r17 zusammengefast auf den Port D?

or r16, r17

gruß markus

Autor: Fehler (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hilft dir wohl auch nicht weiter als das tut., aber,
sind hier vllt. mehr befehle in dt. erklärt?:
Beitrag "Lernunterlage  AVR-Assembler (inkl. Befehle in DEUTSCH)"

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

Bewertung
0 lesenswert
nicht lesenswert
Fehler schrieb:
> hilft dir wohl auch nicht weiter als das tut., aber,
> sind hier vllt. mehr befehle in dt. erklärt?:

Ich hab noch was. Nicht nur für Anfänger.
Entzippen und Verknüpfung nach:
\Atmel-Befehle\beschreibung.html

Autor: Martin Vogel (oldmax)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Markus
Dein Wille etwas über µC zu lernen scheitert meiner Meinung nach daran, 
das du nicht in der Lage bist, Informationen aufzunehmen und anzuwenden. 
Sorry, für diese harte Aussage, aber du vertrödelst wertvolle Zeit in 
Konversation, die nix bringt. Du hast soviele Hinweise bekommen und 
anstatt diese vernünftig durchzugehen, bist du ständig im Forum und 
äußerst dein Unverständnis. Programmieren heißt, im Kreis zu denken und 
darin immer neue Entscheidungen zu treffen. Entscheidungen, die auf 
einfacher logischer Basis getroffen werden.
Ereignis? dann mach das
Wert kleiner, gleich oder größer: dann mach dies
Bit gesetzt: na dann mal los
 und das ganze von vorn
Damit deine Programm überhaupt eine Chance hat, eine Funktin 
auszuführen. solltest du die Schleife lassen
Start: ...
       Initialisieren, Stack setzen, Variablen vorbesetzen usw
Loop:  ...
       hier steht das Programm
       ....
       RJMP Loop ; und hier ist es zu ende
;****************************************
;* ab hier stehen die Unterprogramme    *
;****************************************

Ein solcher Aufbau ist doch nicht so schwer zu verstehen und wenn du 
schon daran scheiterst, ist es vielleicht besser, du suchst dir ein 
anderes Hobby.
Deine Aussagen:
> Die Informationen dazu wie die Drei Komponenten mit einander verbunden
> werden wird natürlich nicht´s erwähne.
Warum, wenn du ein Progrmm schreiben willst, suchst du dir das passende 
heraus. Woher soll denn der Verfasser wissen, was du in welcher 
Verbindung brauchst?

>das sollte doch für ein Programierer doch ein klax sein mal die Drei
>Komponenten mit einander zu verbinden.
Klar, aber warum sollten wir ?

>Und im AVM Studio stehen nicht alle befehle drin. Ausgerechnet die
>befehle die mir Überhaupt nichts sagen fehelen natürlich gruß markus
So ein Befehl wie : Mach das das Geht ? Stimmt, den gibbet nicht.

>PS ich würde mich freuen wenn das hier jemand zusammen basteln kann.
Hier hab ich mich gefragt, was "zusammenbasteln". Deinen fehlerhaften 
Text, damit ihn auch andere verstehen oder dein Wunsch, eben "DAS", 
damit du dich zurücklehnen kannst?

>ich kann auch gerne noch einmal die kompletten getrennten Programme
>Posten.
Wie, du hast mehrere ?
>Außerdem währe das alleine für den Tutorial eine Tolle Sache

>1. At mega8 Sird mit Strom versorgt.
>2. die Daten werden Ausgelesen und Am Port ausgegeben z.b. Port D
>3. die Flip flop Schaltung Hier wird dann die Änderung der Bits Mit
>entprellte taster vorgenommen.
>4. Die geänderten daten werden Überschrieben im Eprom

>Das ist schon alles

Steht glaub ich alles im Tutorial. Das natürlich nicht genau dein 
Problem dort beschrieben ist, solltest du dem Autor nachehen...


Gruß oldmax

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also ich finde den ersten Post garnicht so schlecht.
Er hätte natürlich die Postingregeln beachten müssen, daß es auch lesbar 
ist.

Er braucht natürlich die Entprellung, denn er will ja 8 LEDs mit 8 
Tasten umschalten.

Der Hauptfehler dürfte sein, daß er am Ende kein RET hat, das Programm 
läuft in den Wald.

Er hat in dem Spaghetticode den Überblick verloren:
    ret

  rjmp    main


Wenn man aber alles schön in Unterfunktionen aufteilt (RCALL+RET), dann 
sollte es auch funktionieren.


Peter

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

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:

> Er braucht natürlich die Entprellung, denn er will ja 8 LEDs mit 8
> Tasten umschalten.

Hab ich da was überlesen?
Im Eröffnungsposting ist von EINEM Flip-Flop die Rede, welches über 2 
Tasten angesteuert wird.

Wozu braucht er da Tastenentprellung?


Edit: Ich habs noch einmal durchgelesen. Es ist für mich nicht ganz 
eindeutig was eigentlich wirklich das Ziel ist. Die 2 Tasten werden dort 
nicht explizit erwähnt, nur das
[quote]
Eigentlich wollte ich einen Tasten entprellten Flip flop
[/quote]

Na ja. und da war meine Annahme: 2 Tasten - die eine schaltet ein, die 
andere schaltet aus. Der µC übernimmt das Flip-Flop und schaltet einen 
Ausgang. (Und der Zustand des Ausgangs wird im EEPROM gespeichert und 
beim nächsten Einschalten wieder restauriert, aber soweit ist er noch 
nicht)

Wenn ich da jetzt einen Wirbel hineingebracht habe und den TO in die 
falsche Richtung gelotst haben sollte, entschuldige ich mich dafür.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:
> Edit: Ich habs noch einmal durchgelesen. Es ist für mich nicht ganz
> eindeutig was eigentlich wirklich das Ziel ist.

Ich habs aus dieser Zeile geschlußfolgert:
   eor      leds, temp1            ; Die zur Taste gehörende Led umschalten


Peter

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also Freunde

ich Wollte mit dem atmega8 8 taster ansteuern. zu jeden taster wird dann 
eine LED zugeordnet also PB0 zu PD0 .... PB7 zu PD7
wobei PB als eingang für die tasten genutzt wird und PD für die leds.

Wird der taser 0 ( Pb0 ) gedrückt soll PD0 aufleuchten beim Nästen Druck 
wieder erlöchen

Wird die Stromzufuhr gekappt Sollen die Zustände wieder hergestellt 
werden.
Also muß dann Jerder impuls dann auch im Eprom abgelegt werden. damit 
beim einschalten der Stromzufur die werte Vom Eprom wieder auf den PD 
port hergestellt wird.

Scheint so als ob ihr alle einen eid geschworen habt. Für euch ist es 
simpel für mich zur zeit schwierig.

Auf der Webseite werden zwar einzel komponenten dazu besprochen aber wie 
mann Kombeniert leider nicht. Ich habe mir gedanken gemacht sonst hätte 
ich ja nicht im ersten Posting die asm beigefügt.

ich habe gehoft hier im forum Hilfe zu bekommen und wenn es ebend nicht 
das Prg komplett jemand überarbeitet, dann zumindest doch bemerkungen 
wie Schau mal in zeile X dort Müste dann Folgendes stehen weil 
sonzt.....

das würde mir dann helfen.
Wie soll ich denn so begreifen lernen?
Ich weis ja noch nicht einmal was ich falsch gemacht habe.

Und jeder Profi war einmal ein Anfänger. Oder war es bei euch genauso 
gewesen " Ästsch das geht so nicht ich weis zwar wie aber ich sag es 
nicht"

ich will es lernen das geht aber logischer weise nur step bei step. Und 
mit diesem projekt wollte ich ebend angangen. Später kommen dann weit 
aus Kompleziertere sachen drann.

auf der webseite wird u.a. der befehl or erwähnt mit beispiel nur fehlt 
der aufbau wie dann 2 verschiedene register auf 1 register gesetzt wird 
, so das dann die daten ausgegeben werden können.

Gruß markus

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

Bewertung
0 lesenswert
nicht lesenswert
Markus Andrzejewski schrieb:

> Wird der taser 0 ( Pb0 ) gedrückt soll PD0 aufleuchten beim Nästen Druck
> wieder erlöchen

OK.
Dann hab ich dich falsch verstanden, mein Fehler.

> Scheint so als ob ihr alle einen eid geschworen habt. Für euch ist es
> simpel für mich zur zeit schwierig.

Nö.
In dem Fall musst du tatsächlich im Tutorial weitermachen. Nur mit dem 
ersten Kapitel alleine wird das nichts.

>
> Auf der Webseite werden zwar einzel komponenten dazu besprochen aber wie
> mann Kombeniert leider nicht. Ich habe mir gedanken gemacht sonst hätte
> ich ja nicht im ersten Posting die asm beigefügt.

Du kaprizierst dich zusehr aufs 'kombinieren'
Und das ist der falsche Ansatz.

Du musst NICHT
   3 Bausteine kombinieren

sondern du musst
   ein komplett neues Programm schreiben, wobei du dir Anregungen holst,
   indem du die gezeigten Bausteine studierst.

> ich will es lernen das geht aber logischer weise nur step bei step.

Richtig.
Du versuchst gerade Step 27 zu lösen. Deine Fähigkeiten reichen aber nur 
bis Step 2 oder 3. Und was du nicht wahr haben willst: Du kannst die 
Steps dazwischen nicht einfach überspringen.

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

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> Also ich finde den ersten Post garnicht so schlecht.


Unter der jetzt neuen Prämisse hast du recht.
So weit ist er gar nicht daneben.

Wenn man den Code mal ein bischen aufräumt wäre es gar nicht so schlimm

> Wenn man aber alles schön in Unterfunktionen aufteilt (RCALL+RET), dann
> sollte es auch funktionieren.

Yep.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Markus Andrzejewski schrieb:
> dann zumindest doch bemerkungen
> wie Schau mal in zeile X dort Müste dann Folgendes stehen weil
> sonzt.....

Ich hab Dir doch schon 2 Fehler genannt:
1. RET + RJMP, da muß eins davon falsch sein.
2. Offenes Ende, kein Programm darf ins Nirwana laufen.

und
3. Formatierung benutzen
4. in Funktionen aufteilen.

Mach mal vor jeder neuen Funktion ein:
;-----------------------------------------------------------------------
zur Unterscheidung.


Peter

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

Bewertung
0 lesenswert
nicht lesenswert
Ich hab den Code mal ein bischen aufgeräumt, damit man auch was sieht. 
Alle Unterprogramme an eine Stelle zusammengefasst.
Das Register r16, welches zur Kommunikation mit den EEPROM Funktionen 
dient, wurde freigeschaufelt

und natürlich der Teil rund um die Hauptschleife entsprechend angepasst.

Siehs dir an und studiere, wie die Einzelteile zu einem Gesamtprogramm 
zusammengefügt wurden.
.include "m8def.inc"

.def iwr0      = r1
.def iwr1      = r2

.def key_old   = r3
.def key_state = r4
.def key_press = r5

.def temp1     = r17
.def sreg_save = r18


.equ key_pin   = PINB
.equ key_port  = PORTB
.equ key_ddr   = DDRB

.def leds      = r19
.equ led_port  = PORTD
.equ led_ddr   = DDRD

.org 0x0000
;rcall   EEPROM_read
    rjmp    init

.org OVF0addr
    rjmp    timer_overflow0

;
; *****************************************************************************
;
; Initialisierung
; Alle Komponenten auf die Startbedingungen einstellen
;
init:
;
;  Stackpointer
;
    ldi      temp1, HIGH(RAMEND)
    out      SPH, temp1
    ldi      temp1, LOW(RAMEND)     ; Stackpointer initialisieren
    out      SPL, temp1
;
; Ausgänge
;
    ldi      temp1, 0xFF
    out      led_ddr, temp1
;
; Eingänge
;
    ldi      temp1, 0xFF            ; Tasten sind auf Eingang
    out      key_port, temp1        ; Pullup Widerstände ein
;
; Timer für die Tastenabfrage
;
    ldi      temp1, 1<<CS02 | 1<<CS00   ; Timer mit Vorteiler 1024
    out      TCCR0, temp1
    ldi      temp1, 1<<TOIE0            ; Timer Overflow Interrupt einrichten
    out      TIMSK, temp1

    clr      key_old                ; die Register für die Tastenauswertung im
    clr      key_state              ; Timer Interrupt initialisieren
    clr      key_press

    sei                             ; und los gehts: Timer frei

;
; aus dem EEPROM den letzten Zustand wiederherstellen

    ldi      ZL,low(daten)
    ldi      ZH,high(daten)
    rcall    EEPROM_read            ; Byte ist in r16
  
    mov      leds, r16    

;
; Alles ist eingerichtet. Jetzt gehts mit der eigentlichen Arbeit los
;
main:
    cli                             ;
    mov      temp1, key_press       ; Einen ev. Tastendruck merken und ...
    clr      key_press              ; Tastendruck zurücksetzen
    sei

    cpi      temp1, 0               ; Tastendruck auswerten. Wenn eine von 8 Tasten
    breq     main                   ; gedrückt worden wäre, wäre ein entsprechendes
                                    ; Bit in key_press gesetzt gewesen

    eor      leds, temp1            ; Die zur Taste gehörende Led umschalten
    out      led_port, leds

                                    ; und den neuen Zustand im EEPROM ablegen
                                    ; das Z-Register ist noch vom Lesen an
                                    ; der richtigen Stelle
    mov      r16, leds
    rcall    EEPROM_write

    rjmp     main

;
; *****************************************************************************
;
; Timer Overflow
; wird regelmässig aufgerufen und hat die Aufgabe die Tasten auszuwerten
;
; Eine vollständig gedrückte Taste wird im Register key_press mit einem
; 1 Bit vermerkt. Der Benutzer ist selbst dafür zuständig, dieses Bit
; wieder zu löschen
;
timer_overflow0:               ; Timer Overflow Interrupt

    push    r0                 ; temporäre Register sichern
    in      r0, SREG
    push    r0
    push    iwr0
    push    iwr1

get8key:                       ;/old      state     iwr1      iwr0
    mov     iwr0, key_old      ;00110011  10101010            00110011
    in      key_old, key_pin   ;11110000
    eor     iwr0, key_old      ;                              11000011
    com     key_old            ;00001111
    mov     iwr1, key_state    ;                    10101010
    or      key_state, iwr0    ;          11101011
    and     iwr0, key_old      ;                              00000011
    eor     key_state, iwr0    ;          11101000
    and     iwr1, iwr0         ;                    00000010
    or      key_press, iwr1    ; gedrückte Taste merken
;
;
    pop     iwr1               ; Register wiederherstellen
    pop     iwr0
    pop     r0
    out     SREG, r0
    pop     r0
    reti

;
; *****************************************************************************
;
; Lesefunktion aus dem EEPROM
;
; Die Adresse von der gelesen werden soll, wird im Z-Register übergeben (r30/r31)
;
; Das gelesene Byte bekommt man im Register r16 zurückgeliefert
;
EEPROM_read:
    sbic    EECR,EEWE                   ; prüfe ob der vorherige Schreibzugriff
                                        ; beendet ist
    rjmp    EEPROM_read                 ; nein, nochmal prüfen

    out     EEARH, ZH                   ; Adresse laden
    out     EEARL, ZL
    sbi     EECR, EERE                  ; Lesevorgang aktivieren
    in      r16, EEDR                   ; Daten in CPU Register kopieren
    ret

;
; *****************************************************************************
;
; Schreibfunktion ins EEPROM
;
; Die Adresse an die geschrieben werden soll, wird im Z-Register übergeben (r30/r31)
; Das zu schreibende Byte wird im Register r16 übergeben
;
EEPROM_write:
    sbic    EECR, EEWE                  ; prüfe ob der letzte Schreibvorgang beendet ist
    rjmp    EEPROM_write                ; wenn nein, nochmal prüfen
 
    out     EEARH, ZH                   ; Adresse schreiben
    out     EEARL, ZL                   ; 
    out     EEDR, r16                   ; Daten  schreiben
    in      sreg_save,sreg              ; SREG sichern
    cli                                 ; Interrupts sperren, die nächsten
                                        ; zwei Befehle dürfen NICHT
                                        ; unterbrochen werden
    sbi     EECR,EEMWE                  ; Schreiben vorbereiten
    sbi     EECR,EEWE                   ; Und los !
    out     sreg, sreg_save             ; SREG wieder herstellen
    ret


; Daten im EEPROM definieren
;
.eseg
;
daten:
    .db     0b00000000


Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe das gerade einmal Ausprobiert.

Unabhängig davon das ich jetzt einen Wchselschalter habe, werden die 
daten nicht gespeichert

Muß r16 noch defeniert werden?

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

Bewertung
0 lesenswert
nicht lesenswert
Mangels Hardware konnte ich das nur im Simulator durchspielen.
Aber du hast recht. Ich habe tatsächlich einen Fehler eingebaut.
Nachdem der letzte Zustand aus dem EEPROM gelesen wird, sollte man ihn 
auch auf den Port ausgeben. Sonst ist das holen aus dem EEPROM sinnlos 
:-)

;
; aus dem EEPROM den letzten Zustand wiederherstellen

    ldi      ZL,low(daten)
    ldi      ZH,high(daten)
    rcall    EEPROM_read            ; Byte ist in r16
  
    mov      leds, r16    
    out      led_port, leds

Aber ich klemme mich jetzt ab. Gerade deine letzte Anfrage "Muß r16 noch 
defeniert werden" zeigt mir, dass ich eigentlich schon wieder viel zu 
weit gegangen bin und lässt mich an mir selbst zweifeln, ob das 
Aufräumen und korregieren deines Codes so sinnvoll war.

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Erst einmal Dank

Gibt war immer noch die Gleichen probleme.

Ich werde mal suchen ob ich den fe3hler finde.
Vileicht komme ich ja jetzt weiter
gruß markus

Autor: oldmax (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi
Hab mir grad mal den aufgeräumten Code durchgelesen und bin der Meinung, 
der sollte laufen, wenn nicht der Satz :
>ich Muß gestehen das ich absoluter trittbrett fahrer bin.
wär...
Irgendwo hab ich auch ein Posting gelesen mit einer "geheimen" Schaltung 
von 8 Tastern und 8 LED. Das ist auch gar nicht so schlimm, wenn da die 
Taster nicht auf VCC gelegen hätten.... Da nützen natürlich Pull-Up's 
nicht allzuviel oder besser gesagt unendlich wenig.
Also, diese Zitatsatz war nicht bös gemeint, sondern es könnt sein, das 
du auch dieses Posting gelesen und für deine Zwecke benutzt hast. Oder 
du bist auf den gleichen  Fehler gekommen , da deine Schaltung ja auch 
keiner kennt. Im allgemeinen ist's bei einem solchen kleinen Programm 
auch nicht nötig, einen Schaltplan dranzuhängen, aber es sollte schon 
erwähnt werden. Sind die internen Pull-Ups eingeschaltet, gehören die 
Taster auf GND. Wie du erkennen kannst, ist ein und dasselbe Programm 
auf 2 gleichen Controllern allein durch die Beschaltung nicht lauffähig. 
Auch hier mal ein Tip, grad wenn du weiterhin Assembler benutzen willst. 
Schaff dir eine funktionierende serielle Kopplung und nimm OpenEye um 
die Werte im Controller zu sehen. Dann erkennst du sehr schnell, ob dein 
Programm richtig arbeitet. Die Anleitung und den Download findest du 
hier irgendwo. Vielleicht ist mal einer von den Admins so nett und 
stellt ihn in den Codebereich.
Gruß oldmax

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo oldmax,

Nein Über die "geheime schaltung" binn ich nicht gestolpert.
Kennst du noch den link dazu?

Zur Zeit Funktionieren die taster nicht so wie sie Funktionieren sollen.
Das Funktioniert aber wenn ich das Flip Flop Prg aus dem Tutorial 
alleine laufen lasse.
Die taster sind richtig.

Einen Schaltplan habe ich noch nicht erstellt. habe mich an den 
Pinbelegung des Hersteller gehalten. Und die Übliche Standard 
verdrahtung zur ISP schnittstelle.

5,12V Liegen an.

Gruß markus

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

Bewertung
0 lesenswert
nicht lesenswert
Markus Andrzejewski schrieb:

> Zur Zeit Funktionieren die taster nicht so wie sie Funktionieren sollen.
> Das Funktioniert aber wenn ich das Flip Flop Prg aus dem Tutorial
> alleine laufen lasse.

Die Overflow ISR hab ich nicht mehr kontrolliert.
Hast du die verändert?

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nicht das ich Wüste

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

Bewertung
0 lesenswert
nicht lesenswert
Hmm. Muss dich enttäuschen.
Habs mir gerade mit einem Mega16 zusammengesteckt.
Funktioniert einwandfrei

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hmm Woran kann das Liegen?

Habe den mega 8 gegen einen unbenutzten ersetzt Doch der neue Speichert 
auch nicht´s und macht was er will.

Gruß markus

Autor: Markus Andrzejewski (tubeland)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Speichern tut der  Mega8 nach dem ich eine taste gedrückt habe Stimmt 
der Inhalt mit der datenbank in ASM nicht mehr überein

Gruß markus

Autor: markus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Aua..

Da habe ich beim Selektieren was vergessen.

Nun Jetzt leuft das Prg auch bei mir.
Vielen Dank.

Nun Werde ich mir das Prg genauer anschauen. Denn Verstehen was da  ganz 
genau Passiert ist für mich wichtig.

Dazu Versuche ich eine Detalierte Beschreibung zu bauen.
Wenn ich fertig binn und ihr lust habt dise an zu schauen würde ich mich 
freunen.

Denn Jetzt geht es mir darum alle benutze befehle und derren 
zusammenhänge zu verstehen.



bei elektor habe ich gesehen das die Fern kurse anbieten. Hatt da jemand 
erfahungen mit den Kursus gemacht? Ist das was für mich?

Oder habt ihr Voschläge zu fern kursus für absolut analfabeten?

Gruß markus

Autor: Grrrr (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
markus schrieb:
> Oder habt ihr Voschläge zu fern kursus für absolut analfabeten?

Deutsch für Anfänger an der VHS. (Das konnte ich mir nicht verkneifen).

Ansonsten das viel erwähnt Tutorial.

markus schrieb:
> Nun Werde ich mir das Prg genauer anschauen. Denn Verstehen was da  ganz
> genau Passiert ist für mich wichtig.
Ja ne? Man schaut sich erst das Program an wenn es funktioniert um zu 
verstehen was passiert. Ich lach' mich krank.

Das war doch jetzt alles für die Katz'. Jetzt hast Du das Programm 
zusammen, hast aber überhaupt keine Ahnung wie es funktioniert. Dafür 
aber hie zwei oder drei kompetente Leute mit Pipifax aufgehalten.

Wenn Du von Anfang bis Ende die Tutorien hier durcharbeitest, dann 
hättest Du das Problem selbst lösen können.

Autor: Flip (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mmh...
Du baust und erklärst auf www.tubeland.de "Elektrostaten" uvam. und dann 
hast Du solche Schwierigkeiten µC und LED's zu verstehen? Und sag' jetzt 
nicht, das ist ja auch Digitaltechnik.

..seltsam

-Flop-

Autor: spess53 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi

>Deutsch für Anfänger an der VHS. (Das konnte ich mir nicht verkneifen).

Gilt auch für seine Webseite.

>Das war doch jetzt alles für die Katz'. Jetzt hast Du das Programm
>zusammen, hast aber überhaupt keine Ahnung wie es funktioniert. Dafür
>aber hie zwei oder drei kompetente Leute mit Pipifax aufgehalten.

Vielleicht kann man das aber demnächst in seinem Shop als 
Tastensatz-Ersatz kaufen.

MfG Spess

Autor: markus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Meine Rechtschreibweise ist mir nicht´s neues. Das sind Meine Schwächen. 
Das hatt sich schon herumgesprochen

Damit muß ich leider leben.

Dafür habe ich andere Stärken.

Die 8 Taster schaltung hatte ich nicht vor als Bausatz anzubieten.
Da müssen noch einige Komponenten dazu kommen. Kann auch sein das ich 
dann Später auf eine andere CPU ausweichen muß.

Und wenn das so währe, hätte ich den Programierer Privat kontaktiert und 
mir ihn zusannen eine Faire Lösung ausgearbeitet.

Oder ich Hätte jemanden das im Auftrag gegeben, gegen bezahlung oder 
nach verkaufte Lizenzen.

Leben und leben lassen.

Betruch und ähnliche Sachen lasse ich mir nicht nachreden. ist Tötlich 
fürs geschäft.

Und wenn ich mich nach 10 jahren entscheide das Als Tasten bausatz 
anzubieten. Dann würde ich auf jeden fall mit den Programierer eine 
vereinbarung Treffen. Er hatt es Schließlich auch geschrieben und nicht 
ich.



Also Ihr meint Mit hilfe des tutors müste ich es packen?

wie gesagt ein Fern studium würde ich auch dran teil nemen.
Nur zu wem gehen?

ja ich hätte mich vor jahren damit auseinander setzen sollen. erkannte 
darmals nicht die Fielfalt an Möglichkeiten die so ein Controler bietet.
Ideen sind genug da.
und bis heute habe ich auch jede von denen umgesetzt.
das wird auch in ein parr jahren mit den Controler der fall sein.

Gruß Markus

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.