Zur jeder Zeit der Programmlaufzeit, Tastendruck speichern

[ckrex (Gast)]

Frohes Neues!

erstmal der code...

main.asm

.include "m16def.inc"
.include "init_def.inc"



INIT:
  ldi temp, 0xFF
  out DDRC, temp ;define Portc as output
  out DDRB, temp ; define PORTB as output

  ldi temp, 0x00
  out DDRD, temp ; define PORTD as input
  ldi temp, 0xFF
  out PORTD,   temp ;activate pull ups

  ldi r26, 0xFF  ;
  ldi r27, 0xFF  ;for wait

  ldi cnt, 20 ; load loop counter with 20


MAIN:
  rcall YELLOW_LED_ON
  
  rcall WAIT; wait
  rcall YELLOW_LED_OFF
  
  
  rcall lOW_WAIT
  ;rcall WAIT
  
  in temp, PIND; write PIND to temp

  sbrs temp, 0 ;skip if bit 0 in temp is cleared
  ;if there is some input
  ;execute LED ON
  ;else if there is no input, then do not activate led
  rcall RED_LED_ON

  rjmp MAIN ; jmp to MAIN label

  

LOW_WAIT: ;wait only 250 ms
  sbiw r27:r26, 1 ; sbiw takes 2 clocks
  brne LOW_WAIT    ;branch if not equal ; takes 2 clocks if condition is true
  ldi r26, 0xFF  ;set
  ldi r27, 0xFF  ;back
  ret



WAIT:
  ldi r26, 0xFF  ;set
  ldi r27, 0xFF  ;back
  
  dec cnt
  brne LOOPINNER_WAIT
  
  ldi cnt, 20 ;restore
  ret
  
  
LOOPINNER_WAIT:
  sbiw r27:r26, 1 ; sbiw takes 2 clocks
  brne LOOPINNER_WAIT    ;branch if not equal ; takes 2 clocks if condition is true
  rjmp WAIT


YELLOW_LED_ON:
  ldi temp, 0xFF
  out PORTB, temp
  ret  


YELLOW_LED_OFF:
  ldi temp, 0x00
  out PORTB, temp
  ret  


RED_LED_ON:
  ldi temp, 0xFF
  out PORTC, temp
  ret

init_def.inc

#ifndef _INIT_DEF_INC_
#define _INIT_DEF_INC_

.def temp = r16
.def cnt = r17


.org 0x0000        ; Adresse im 2er schritt ;Die Interruptvektortabelle beginnt bei 0x0000 
rjmp    MIN_INIT      ;1 POWER ON RESET 
.org 0x0002
reti  ;2 Int0-Interrupt 
.org 0x0004
reti  ;3 Int1-Interrupt   
.org 0x0006
reti          ;4 
.org 0x0008
reti          ;5 
.org 0x000a
reti          ;6 
.org 0x000c
reti          ;7 
.org 0x000e
reti          ;8 
.org 0x0010
reti          ;9 
.org 0x0012
reti          ;10 
.org 0x0014
reti          ;11 
.org 0x0016
reti          ;12 
.org 0x0018
reti          ;13 
.org 0x001a
reti          ;14 
.org 0x001c
reti          ;15 
.org 0x001e
reti          ;16 
.org 0x0020
reti          ;17 
.org 0x0022
reti          ;18 
.org 0x0024
reti          ;19 
.org 0x0026
reti          ;20
.org 0x0028
reti          ;21


MIN_INIT:            ;RESET Label 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ldi temp, high(RAMEND)  ;Initialisierung des Stackpointers 
  out SPH, temp      ;erst das High - Byte 
  ldi temp, low(RAMEND) 
  out SPL, temp      ;dann das Low - Byte
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; nötig um alle pins an portc zu verwenden

  in temp,MCUCSR         ; Read MCUCSR
  ori      temp,1 << JTD        ; Set jtag disable flag
  out      MCUCSR, temp         ; Write MCUCSR
  out      MCUCSR, temp        ; and again as per datasheet 

  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

#endif

Wie man im Programm erkennen kann wird eine gelbe Led ca 5 Sekunden 
eingeschaltet (1mhz µController), dann wird für ca 0,25 Sekunden 
gewartet. Anschließend wird geprüft ob der nullte pin von portD auf 
Masse gezogen wurde. Ist dies der Fall, dann wird die rote Led 
angeschaltet. Wenn man den nullten pin von portd mit Masse verbindet 
während die Überprüfung des Portregisters PIND nicht abgefragt wird und 
man dann die Verbindung zur Masse unterbricht, dann wird nicht 
gespeichert, dass der pin währenddessen jemals mit Masse verbunden war. 
Nun zu meiner Frage: Hat der µController eine Art Puffer der speichern 
kann, dass der pin zu jeder zeit des Programms mit Masse verbunden war? 
Theoretisch könnte man das irgendwie hardwaremäßig mit einem 
selbsthalterelai realisieren, dies möchte/kann ich aber nicht.

Gruß

[Achwas (Gast)]

Erzähl doch lieber kurz und nachvollziehbar, was das Programm so
alles machen soll - und was es nicht macht.

Sich in den Code ohne Beschreibung einzulesen, macht selten Spaß.

[Thomas H. (Firma: CIA) (apostel13)]

Noch Restalkohol im Blut vom Silvester Feiern?

[Max D. (max_d)]

Das macht man normalerweise indem man öfter abtastet.
Der User braucht ja eine gewisse Zeit um den Knopf wieder loszulassen 
und in dieser Zeit muss man mindestens einmal nachsehen.
Bei sehr speziellen Lösungen kann man das auch per Interrupt lösen.

[Jörg E. (jackfritt)]

Ohne Wait arbeiten?
Z.b. Timer verwenden der in der ISR ständig eine Variable hochzählt und 
den Portpin abfragt. Die Variable nutzt du als Zeitwert für deine LED 
ein und Ausschaltvorgänge.
Schau mal bei Peter Danneggers entprellroutinen, da is auch ne asm 
Version und ich meine mit Timer.

[ckrex (Gast)]

Das Programm das dort zu sehen ist, wurde nur zu Testzwecken erstellt um 
eine Lösung für mein oben gennantes Problem zu finden. Ursprünglich bin 
ich dabei eine Ampelschaltung zu programmieren.

>Das macht man normalerweise indem man öfter abtastet.


Achja? Ich meine das ist z.B. bei der Bibliothek ncurses-dev nicht der 
Fall. Ich kann mich aber auch irren. Da konnte man nämlich in einer 
Schleife hängen die z.B. nur wartet. Während der Computer diese Schleife 
ausführte und der User auf der Tastatur eine Taste drückte, dann wurde 
der Tastendruck gespeichert und bei der nächten Auswertung des 
"Tastaturpuffers" wurde der Tastendruck von dem Computer registriert.
UND das ganze mit nur einer Abfrage. Das möchte ich auch am liebsten für 
den µController realisieren.

>Das macht man normalerweise indem man öfter abtastet.
>Der User braucht ja eine gewisse Zeit um den Knopf wieder loszulassen
>und in dieser Zeit muss man mindestens einmal nachsehen.

Wäre möglich, aber nicht ideal.
Außerdem würde dafür einfach viel Rechenzeit bei drauf gehen wenn ich 
immer diesen Pin abfrage.


>Bei sehr speziellen Lösungen kann man das auch per Interrupt lösen.
Ich möchte es nicht mit einem interrupt lösen. Das hab ich wohl 
vergessen in meine ersten Post zu erwähnen.


>Noch Restalkohol im Blut vom Silvester Feiern?

Nein. Und selber? :)

Gruß

[Noch einer (Gast)]

>Ich möchte es nicht mit einem interrupt lösen.

Ich eigentlich auch nicht. Mit Interrupts wird es aber einfacher als 
ohne.

In deinem Beispiel müsstest du ja in der Warteschleife den Taster 
abfragen. Ampel mit einem Taster ginge vielleicht noch. Sobald du 
Programme schreibst, die 5 Dinge gleichzeitig machen, wird das Programm 
zu unübersichtlich - du findest die Fehler nicht mehr.

[Jörg E. (jackfritt)]

Was meinst du denn wieviel Rechenzeit in deiner Wait Routine draufgeht?

[Peter D. (peda)]

ckrex schrieb:
> Nun zu meiner Frage: Hat der µController eine Art Puffer der speichern
> kann, dass der pin zu jeder zeit des Programms mit Masse verbunden war?

Der Trick an einem MC ist, er macht nur genau das, was man programmiert 
hat und er macht es genau und nur dann, wenn der entsprechende Code 
ausgeführt wird.
Anders gesagt, von alleine macht er garnichts, Du must es programmieren.

Z.B. einen Ereignispuffer, indem man einen Timerinterrupt aufsetzt, der 
zyklisch auf das Ereignis abfragt und den Erfolg in einer Variablen 
ablegt.

[ckrex (Gast)]

>Ampel mit einem Taster ginge vielleicht noch. Sobald du
>Programme schreibst, die 5 Dinge gleichzeitig machen, wird das Programm
>zu unübersichtlich - du findest die Fehler nicht mehr.

Der Wille ist ALLES! Und der Glaube.
Insgesamt habe ich 2 Taster und 2 reed kontakte die quasi eine 
induktionschleife darstellen sollen. Also insgesamt 4 Schalter.

Ich werde das ganze nun anders implementiren als gedacht.
Nämlich über mehrfaches Abfragen des Eingangsports.
Der Thread kann von mir aus geschlossen werden ;)