Hallo Gemeinde,
ich muss für ein Projekt 3 Signalgeber auslesen, wenn ich den "taster"
drücke liegt am µC eingang ein low-signal an, ich möchte nun, dass das
signal gespeichert wird,auch wenn der "taster" wieder losgelassen
wird... mit erneutem betätigen möchte ich, dass das signal wieder
zurückgesetzt wird.
Ich lasse das ganze dauerhaft durchlaufen damit immer alle drei
Signalgeber "gleichzeitig" betätigt werden können... Hat da jemand eine
Idee? In Richtung FlipFlop in Assembler?
Gruß Bernd
bernd schrieb:> Signalgeber "gleichzeitig" betätigt werden können... Hat da jemand eine> Idee? In Richtung FlipFlop in Assembler?
Ich wollte dir schon ein komplettes ASM-Listing schicken. Alles fertig
incl. Signal und Flipflop. Leider wußte ich nichts über deinen µC,
dienen Assembler, nichts über das ominöse Signal und wie es von den
Signalgebern geliefert wird. Ich bin jetzt total frustriert, daß ich dir
nicht helfen kann :( Leider hab ich gleich keine Zeit mehr und will dir
auch keinen Pseudocode zumuten.
Ok also ich habe einen pic18 und an ra0 bis ra2 sensoren die wenn diese
schalten auf masse gehen... rb0 bis rb2 sind meine ausgänge... wenn
sensor 1 schaltet, soll rb0 1-signal ausgeben... solange bis sensor 1
ein zweites mal schaltet. Das gleiche mit sensor 2 und 3 =》rb1 und rb2
Naja im prinzip nichts... ich wollte mein projekt nur näher erläutern...
mir geht es darum dass ich keine lösung finde da signal zu speichern,
wenn ich den eingang auslese, sprich:
Main
btfss ra0
bsf rb0
btfss ra1
bsf rb1
btfss ra2
bsf rb2
goto Main
-------------------^
somit bleiben die ausgänge immer an und bei erneuter betätigung ändert
sich logischerweise nichts... wie kann muss ich also weiter vorgehen um
sozusagen ein T-FlipFlop zu simulieren ? Oder hat jemand einen anderen
ansatz? Hardwareseitig kann ich keine flipflops mehr ergänzen... auch
die Pinbelegung am Pic kann ich nicht mehr ändern...
Pseudocode:
Lbl1:
in Tasten, Zustandsspeicher ; Tasten einlesen
and Zustandsspeicher, 7 ; Untere Drei Bit rausfiltern
cpi Zustandspeicher, 7 ; wurde Taste gedrückt?
jz Lbl1 ; wenn nicht wiederholen
not Zustandsspeicher ; gedrückte Taste = H
xor Ausgaberegister, Zustandsspeicher ; xor bewirkt den ToggleSwitch
out Ausgaberegister, Ausgang ; Ausgänge setzen
jmp Lbl1 ; springe zum Anfang
Die Sache hat nur einen kleinen Haken: solange eine oder mehrere Tasten
gedrückt sind, toggelt der Ausgang ständig hin und her...
Wenn eine Umschaltung durch einen Tastendruck stattgefunden hat, muss
also das weitere gedrückt-halten der Taste ignoriert werden, bis sie mal
wieder losgelassen wird. Und: wenn die "Sensoren" tatsächlich richtige
Tasten mit mechanischen Kontakten sind, muss auch noch entprellt werden!
Hi
Deinen Assembler kenn ich zwar nicht, dennoch sollte es möglich sein,
dir zu erklären, wie das funktioniert. Das Zauberwort heißt
Flankenbildung.
Du hast einen Kontakt, also must du das Eingangssignal erst einmal
entprellen. Dazu nimmst du den Eingang und prüfst, ob ein Wechsel
stattgefunden hat. Bei jedem Wechsel setzt du einen Zähler, sagen wir
mal auf 5, den du im ms Takt runterzählst. Ist er zu 0 geworden, sollte
dein Eingang stabil sein und du kannst ihn erst mal ablegen. Nun kommt
die Flanke dran. Auch hier wieder Neu mit einer Ablage vergleichen.
Exclusiv-Oder. Ist ein Unterschied, hat ein Wechsel stattgefunden. Nun
musst du herausbekommen, ob der Wechsel von 1 nach0 oder umgekehrt ist.
Also nochmal den altenZustand mit der Änderung verunden. War Alt "1" und
die Änderunf "1" ist klar. der Wechsel war von 1 nach 0. Ist aber der
neue Zustand "1", bedutet das ebenfalls mit dem Ergebnis aus Exclisiv
Oder einen Wechsel von 0 nach 1. Hier mal dazu einen Assemblertext vom
Atmega
[avraasm]
;*********************************************************************
;* Flankenbits bilden *
;*********************************************************************
Set_IO_Event: ; Flankenbits setzen
LDS r16, Akt_In ; aktuell gültige Eingänge lesen
MOV r6, r16 ; Wert merken
LDS r17, old_in ; Ablage gültiger Eingänge
EOR r16, r17
BREQ End_Io_Event ; keine Änderung, dann Ende
MOV r7, r16 ; Ergebnis merken
AND r17, r16 ; alte Bits und Ergebnisbits = Wechsel 1 auf 0
LDS r18, Event_0 ; offene Ereignisse laden
OR r17, r18 ; neue Ereignisse zumischen
STS Event_0, r17 ; und Ereignis fallende Flanke ablegen
MOV r16, r6 ; aktuelle Bits laden
MOV r17, r7 ; aktuelle Bits und Ergebnisbits = Wechsel 0 auf 1
AND r17, r16
LDS r18, Event_1 ; offene Ereignisse laden
OR r18, r17 ; neue Ereignisse zumischen
STS Event_1, r18 ; und Ereignis steigendeFlanke ablegen
MOV r16,r6 ; aktuelle Bits laden
STS old_in, r16 ; aktuelle Eingänge nach Ablage
End_Io_Event:
RET
;-----------------------------------------------------------------------
-
[/avrasm]
Ich hoffe, du hast es verstanden und kannst es umsetzen.
Gruß oldmax
bernd schrieb:> wie finde ich den meinen "assembler" herraus?
Grob: Welchen Microcontroller verwendest du? "BTFSS" hört sich schon mal
nach PIC an.
Fein: Welches Programm verwendest du um deine Assembler-Programme zu
assemblieren?
Schüler und nicht aufgepaßt?
PIC18 ist schon mal gut.
Wie sieht die Programmierumgebung aus? Hardware vorhanden? Von der
Schule gestellt? Keine Lust einzuarbeiten?
Machen wir alles für dich.
Aber nenn doch ein paar Eckdaten.
Pic sitzt auf einer selbstgeätzten platine und ich verwende ein
pickit3... pickkit2 habe ich auch...
Und ja... schüler... aufpassen war nicht möglich da wir dies noch nicht
behandelt haben... :/
Naja.
Logische Zustände speichert man in Variablen.
Alte logische Zustände kann man dort nachsehen und mit den neuen
logischen Zuständen vergleichen.
Bei Ungleichheit kann man Aktionen ausführen.
Und den neuen Zustand kann man als alten speichern.
Schleife drumrum (nicht Schmuckband, sondern programmtechnisch
ausgeführt).
Fertig.
Das bedeutet ich frage den eingang ab und speichere den zustand in einer
variable... wenn ich den eingangszustand ändere, ändere ich nicht direkt
den ausgang sondern zuerst die variable
,,,,,,,,,,,,,,,,,,,,,,,,
Variable:
Sensor1 equ 0x20
Main:
btfss ra0
bsf sensor1
.
.
.
goto Main
,,,,,,,,,,,,,,,,,,,,,,,,,,,,
Wie kann ich dann beim 2. Durchlauf den alten mit dem neuen Zustand
vergleichen
>Wie kann ich dann beim 2. Durchlauf den alten mit dem neuen Zustand>vergleichen
Wenn das eine Frage war, dann hier die Antwort:
Einfache Logik, so wie im Alltagsleben auch. Befehle dazu in der
Beschreibung des µC.
Selber machen und selber lernen ist immer gut.
bernd schrieb:> wie finde ich den meinen "assembler" herraus?
Datasheet + Familie Reference.
Die einzigen Informationequellen die Dir sagen können wie genau Deine
MCU funktioniert.
Ohne jetzt wieder Grundsatzstreitigkeiten hervorzurufen, aber warum
quälst Du Dich so ?
Der assemblerbefehlssatz einer jeden MCU ist anders, Du fängst also bei
jedem Wechsel wieder von vorn an.
Du must Dich in Asssembler um jeden Mist selber kümmern und immer wissen
mit welchem Register Du was für Operationen machen kannst und wo Du
gerade was gespeichert hast.
Das ist eine wahnsinnige Quälerei wenn der Umfang steigt und der
Performancegewinn gegenüber C ist in den meisten Fällen völlig
bedeutungslos.
Microchip bietet kostenlose C Compiler und der Sprachumfang von C ist so
klein das Du sehr schnell zu funktionierenden Programmen kommst.
Was in C nur ein Befehl ist kann im Assemblerhintergrund xKB an code
sein.
In C kannst Du auf umfangreiche Standartbilbiotheken zurückgreifen oder
ganz nah an der Hardware selber programmieren.
Mach Dir das nicht so schwer und fang mit C an.
Du kannst immer noch Assembler an den Stellen benutzen wo es um die
Wurst geht und jeder Taktzyklus zählt.
Michael Knoelke schrieb:> Du must Dich in Asssembler um jeden Mist selber kümmern und immer wissen> mit welchem Register Du was für Operationen machen kannst und wo Du> gerade was gespeichert hast.
Falsch! "c-hater" würde schreiben: In Assembler hast Du endlich die
Macht, und nicht irgend ein Compiler.
Du bist Herr über jedes Bit, jeden Takt und jede Speicherzelle.
Abgesehen von diesem endlosen Disput, hat die Schule dem TO die Aufgabe
gestellt, diese in Assembler zu lösen.
Nur Mut! Assembler-Programmierer werden gesucht, wenn es um
sicherheitskritische Software geht. Da gibt es keine versteckten
Compiler-Bugs. Ansonsten müssen die verwendeten Entwicklungsumgebungen
zertifiziert oder validiert werden. Bei Assembler alles kein Thema.
> andwf maske,W ;nur gedrückte Taster, die sich geändert haben
7
> andlw b'00000111' ;und nur die unteren Bits
8
> xorwf PORTB,F ;toggeln
9
>
Eleganter geht es, wenn man die Bits invertiert speichert, dann ist die
Variable "maske" nicht mehr notwendig und zwei Befehle fallen weg:
Thomas Elger schrieb:>
1
> comf PORTA,W ;aktuellen Status invertiert einlesen
2
> xorwf speicher,W ;Änderung gegenüber alten Wert => 1-Bits in W
Route 66 schrieb:> hat die Schule dem TO die Aufgabe> gestellt, diese in Assembler zu lösen.
Ja ?
Das muß ich überlesen haben.
Wo steht das denn ?
> Du bist Herr über jedes Bit, jeden Takt und jede Speicherzelle.
Ja ich kenne die Vorteile von Assembler.
Kennst Du denn auch die Nachteile ?
ASM ist ein steiniger Weg.
Die ersten kleinen Sachen gehen recht schnell und wenn es dann größer
wird geht schnell garnichts mehr weil man sich hoffnungslos verzettelt
und zwei Tage später seinen eigenen Code nicht mehr versteht.
Hi
Michael Knoelke schrieb:> Die ersten kleinen Sachen gehen recht schnell und wenn es dann größer> wird geht schnell garnichts mehr weil man sich hoffnungslos verzettelt> und zwei Tage später seinen eigenen Code nicht mehr versteht.
Das kann dir mit jeder anderen Programmiersprache aber auch passieren.
Liegt halt daran, wie du dir deine Struktur zurechtlegst. Da sind auch
größere Programme nicht unbedingt schlecht zu überschauen.
Natürlich auch ganz klar, wenn andere Programmierer sich über den Code
hermachen (müssen), ist es ungleich schwieriger, wie in einer
Hochsprache.
Gruß oldmax
