PIC 12F675 Tastendruckzeit auswerten in Assembler

[DL4VAL]

Danke Christian
Das sehe ich mir mal in Ruhe an.
Danke nochmals für den Tipp mit GOTO.
Das hat an anderer Stelle einen Fehler verursacht, dass der PIC gerade das gemacht hat, was ich Ihm gesagt habe: Wirres Zeug.
Hat keinen richtigen Ablauf mehr gegeben und der PIC hat sich undefiniert aufgehängt.
Gruß Bernd

- - - Aktualisiert - - -

Hallo oberallgeier
Danke für Deinen Vorschlag.
Habe das gestern etwa so gelöst, wie Du es beschrieben hast.(Hast sich für mich schlüssig gelesen )
Taste losgelassen: Alle Variablen auf Start (ini)
Taste gedrückt:Steuere UP für langsames blinken an und vermindere bei jedem Durchlauf eine Variabel (Endwert)
Ist das ganze 10 mal Durchgelaufen, hat der Ausgang ja 10 langsame Impulse zum Feineinstellen gemacht.
(lasse ich die Taste zwischendurch, los beginnt das aufs neue)
Ist der Zähler auf NULL, dann springt der PIC in UP für schnelles Blinken und setzt dort einen Merker
damit das Teil weiß, dass es schon in UPschnell war und weiter dort arbeiten soll.
Das ist für meine Anwendung ausreichend. Wenn jetzt die Endschalter der Drehkondensators kommen wie DIR umgedreht,
FERTISCH.

Jetzt werde ich das ganze noch etwas übersichtlicher gestalten.
Habe das funktionierende Programm mal eingestellt.
Ab und an blinkt noch ohne Tastendruck die Impuls-LED auf.
Weiß aber nicht ob das vom Programm oder der Beschaltung des PIC kommt.
Habe die Eingänge mit 100nF auf Masse gelegt, aber kommt immer noch ab und an.
Falls noch einer drüber guckt und eine Verbesserung/Fehler findet, wäre nett mir eine Info zukommen zu lassen.
Danke.
Gruß Bernd

;**********************************************************************
;                                                                     *
;    Filename:	    Impulsgeber_Neu.asm                               *
;    Date:          11.05.2013                                        *
;    File Version:                 001                                *
;                                                                     *
;    Author:        Bernd Kunz                                        *
;    Company:       private                                           *
;                                                                     *
;                                                                     *
;**********************************************************************
;                                                                     *
;    Files Required: P12F675.INC                                      *
;                                                                     *
;**********************************************************************
;                                                                     *
;    Notes: Schrittmotor drehen mit Impulsen                          *
;           Richtungssignal für links oder rechts Drehen.             *
;			Endschalter beendet Drehung am Ende des Verfahrweges      *
;			Halten des Tasters erhöht die Drehgeschindigkeit          *
;			Einsatz am Drehkondensator einer Magnetic-Loop			  *
;**********************************************************************
;**********************************************************************
;*  	Pinbelegung													  *
;*	----------------------------------								  *
;*	GP: 0 <  ein links drehen										  *
;*		1 <  ein rechts drehen										  *
;*		2 <  ein linker Endschalter									  *
;*		3 <  ein rechter Endschalter								  *
;*		4 >  Ausgang Impulse										  *
;*		5 >  Ausgang Richtungssignal								  *	
;*																	  *		
;**********************************************************************
	list      p=12f675            ; list directive to define processor
	#include <p12f675.inc>        ; processor specific variable definitions

	errorlevel  -302              ; suppress message 302 from list file

	__CONFIG	_MCLRE_OFF & _PWRTE_OFF & _WDT_OFF & _INTRC_OSC_NOCLKOUT & _BODEN_OFF
;******************************Wichtig*************************************************

; Variablennamen vergeben 
	CBLOCK 0x20
	w_temp             	;variable used for context saving 
	status_temp        	;variable used for context saving
	loops              	;Zähler für Warteschleife  
	loops2             	;Zähler für Warteschleife  
	Endwert 			;Wieviele Impulse vergehen bis auf schnelle Warteschleife umgeschaltet wird.  
	Merker				;Endwert erreicht
	Endwert2 			;Wieviele Impulse vergehen bis auf schnelle Warteschleife umgeschaltet wird.  
	Merker2				;Endwert erreicht
	links1gesetzt
	rechts1gesetzt
	ENDC
	
	
;***********************************************************************
	org	0x00
	call	Init
	goto    main              ; go to beginning of program
	org 0x4
	goto main

;***********************************************************************
; Initialisierung
Init
	; IO-Pins
	bcf	STATUS, RP0			; Bank 0   		Im Register Status wird was? auf 0 gesetzt !!!!Umschaltung auf Bank 1  
	clrf	GPIO			; aus!		CLRF GPIO  ;In das Register GPIO wird 0 geschrieben
	movlw	b'00111111'		;Set GP<5:0> to digital IO  !!!!!!!WICHTIG!!!!!!! Digital setzen nicht analog
	movwf	CMCON			; Comparator aus		CMCON — COMPARATOR CONTROL REGISTER setzen
	;Ab hier die Aus- und Eingänge setzen.
	bsf	STATUS, RP0			; Bank 1
	clrf ANSEL 				;Digital I/O
	movlw   b'00001111'		;Setze GP<3:2:1:0> als Eingang und setze GP<5:4> ist Ausgang 
	movwf   TRISIO			;movwf TRISIO ;Schreibe das Trioregister mit den Werten
	;Endwert setzen je höher um so länger wird gewartet bis es schneller geht
	MOVLW 0xA			;Lade Wert dezimal 10 in W
	MOVWF Endwert		;Lade W in Variable Endwert
	MOVLW 0				;Merker mit 0 intialisieren
	MOVWF Merker		;Lade W in Variable Merker
	MOVLW 0
	MOVWF links1gesetzt
	;************************************************
	MOVLW 0xA			;Lade Wert dezimal 10 in W
	MOVWF Endwert2		;Lade W in Variable Endwert2
	MOVLW 0				;Merker mit 0 intialisieren
	MOVWF Merker2		;Lade W in Variable Merker2
	MOVLW 10
	MOVWF rechts1gesetzt
	
	bcf	STATUS, RP0		; Bank0
						; ; internen Taktgenerator kalibrieren
						; bsf	STATUS, RP0		; Bank 1
						; call	0x3FF
						; movwf	OSCCAL			; 4-MHz-Kalibrierung
						; bcf	STATUS, RP0		; Bank 0
	; Interrupt
	bcf	INTCON, GIE		; Int deaktiviert


; *****************************Unterprogramme***************************	

prüfen					;Wie lange wurde die Taste gedrückt?
	DECFSZ Endwert,f	;Endwert ist Anfangs mit 10 geladen subtrahiere 1
						;Falls das 0 ergibt, dann ignoriere den nachfolgenden Befehl
	INCF Merker,f			;Erhöhe Merker um 1 wenn Endwert nicht auf 0 ist
	DECFSZ Merker,f    	;Verringere den Wert von Merker um 1. Falls das 0 ergibt, dann ignoriere den nachfolgenden Befehl
	call links1			;Solange der Endwert zwischen 1 und 10 ist ist der Merker auf 0, Wenn der Merker auf 0 ist gehe links 
	;Springe da hin und nicht wie mit call wieder zurück
	DECFSZ links1gesetzt,f
	call links
	;Hier muß eine initlinks hin Endwert auf 1 und Merker auf 0 damit das schnelle bleibt
	return

	
inilinks			;********************************Rücksetzen wenn Eingang GPIO0 auf 0 geht*****************************
	MOVLW 0xA		;Lade Wert dezimal 10 in W
	MOVWF Endwert	;Lade W in Variable Endwert
	
	MOVLW 0			;Merker mit 0 intialisieren
	MOVWF Merker	;Lade W in Variable Merker
	
	MOVLW 0
	MOVWF links1gesetzt
	;BTFSC 	GPIO,0		
	;call links
	return

inirechts			;********************************Rücksetzen wenn Eingang GPIO0 auf 0 geht*****************************
	MOVLW 0xA		;Lade Wert dezimal 10 in W
	MOVWF Endwert2	;Lade W in Variable Endwert
	
	MOVLW 0			;Merker mit 0 intialisieren
	MOVWF Merker2	;Lade W in Variable Merker
	MOVLW 0
	MOVWF rechts1gesetzt	
	;BTFSC 	GPIO,0		
	;call links
	return	

prüfenrechts					;Wie lange wurde die Taste gedrückt?
	DECFSZ Endwert2,1	;Endwert ist Anfangs mit 10 geladen subtrahiere 1
						;Falls das 0 ergibt, dann ignoriere den nachfolgenden Befehl
	INCF Merker2,f			;Erhöhe Merker um 1 wenn Endwert nicht auf 0 ist
	DECFSZ Merker2,1    	;Verringere den Wert von Merker um 1. Falls das 0 ergibt, dann ignoriere den nachfolgenden Befehl
	call rechts1			;Solange der Endwert zwischen 1 und 10 ist ist der Merker auf 0, Wenn der Merker auf 0 ist gehe links 
	;Springe da hin und nicht wie mit call wieder zurück
	DECFSZ rechts1gesetzt,f
	call rechts
	;Hier muß eine initlinks hin Endwert auf 1 und Merker auf 0 damit das schnelle bleibt
	return

	

	
	
	
; DECFSZ 	Verringere den Wert aus der Speicherzelle f um 1. Falls das 0 ergibt, dann ignoriere den nachfolgenden Befehl.
; Syntax: 	DECFSZ  f,d
; Bedeutung: 	wenn d=0:
; Vom Wert in f wird 1 abgezogen, und das Ergebnis in W gespeichert.

; wenn d=1:
; Vom Wert in f wird 1 abgezogen, und das Ergebnis wieder in f gespeichert.

; Ist das Ergebnis der Subtraktion Null, dann wird der nächste Befehl im Programm übersprungen, und mit dem übernächsten weitergebacht.
; Beispiel: 	DECFSZ 0x20,1  ; Der Inhalt der Speicherzelle mit 
; der Adresse 20h wird um 1 erniedrigt



links1				;Schnelle Impulse
	MOVLW 1			;Lade Wert dezimal 1 in W Läd immer wieder Endwert mit 1 Um wieder hierhin zu springen.
	MOVWF Endwert	;Lade W in Variable Endwert
	MOVLW 0			;Merker mit 0 intialisieren
	MOVWF Merker	;Lade W in Variable Merker


	bsf GPIO,5		;PIN 5 ist auf Masse Richtungssignal 
	BTFSC GPIO,2	;Endschalter abfragen (Wenn Eingang auf Masse dann übergehen)
	bcf GPIO,5		;PIN 5 ist auf PLUS, (Richtungssignal umkehren, wenn der Endschalter kommt)
		;*******************
	bsf GPIO,4             	; LED an 
    call warten1            ; 250 ms warten 
    bcf   GPIO,4            ; LED aus 
    call warten1            ; 250 ms warten 
    MOVLW 1
	MOVWF links1gesetzt
	return
	
links				; langsame Impulse und Richtung links ein/aus-schalten
	bsf GPIO,5		;PIN 5 ist auf Masse Richtungssignal 
	BTFSC GPIO,2	;Endschalter abfragen (Wenn Eingang auf Masse dann übergehen)
	bcf GPIO,5		;PIN 5 ist auf PLUS, (Richtungssignal umkehren, wenn der Endschalter kommt)
		;*******************
	bsf GPIO,4             	; LED an 
    call  warten            ; 250 ms warten 
    bcf   GPIO,4            ; LED aus 
    call  warten            ; 250 ms warten 
    return

;**********************************************************************
;Schnelle Impulse und Richtung rechts ein/aus-schalten
rechts1
	MOVLW 1			;Lade Wert dezimal 1 in W Läd immer wieder Endwert mit 1 Um wieder hierhin zu springen.
	MOVWF Endwert2	;Lade W in Variable Endwert
	MOVLW 0			;Merker mit 0 intialisieren
	MOVWF Merker2	;Lade W in Variable Merker
		
	bcf GPIO,5		;PIN 5 ist auf PLUS Richtungssignal
	BTFSC GPIO,3	;Endschalter abfragen (Wenn Eingang auf Masse dann übergehen)
	bsf GPIO,5		;PIN 5 ist auf Masse (Richtungssignal umkehren, wenn der Endschalter kommt)
	;*****************
	bsf GPIO,4             	; LED an 
    call  warten1            ; 250 ms warten 
    bcf   GPIO,4            ; LED aus 
    call  warten1            ; 250 ms warten 				
	;*****************
	MOVLW 1
	MOVWF rechts1gesetzt
	return

rechts		;Langsame Impulse
	bcf GPIO,5		;PIN 5 ist auf PLUS Richtungssignal
	BTFSC GPIO,3	;Endschalter abfragen (Wenn Eingang auf Masse dann übergehen)
	bsf GPIO,5		;PIN 5 ist auf Masse (Richtungssignal umkehren, wenn der Endschalter kommt)
	;*****************
	bsf GPIO,4             	; LED an 
    call  warten            ; 250 ms warten 
    bcf   GPIO,4            ; LED aus 
    call  warten            ; 250 ms warten 				
	;*****************
	return

;*****************************Neue Warteschleifen*********************************************
warten1
	;schnell
;************************************************************
; Warteschleife 10 ms
        movlw   D'10'         ; 100 ms Pause
        movwf   loops 
        goto    Wai
	
warten
	; Langsam		
	;*********************************************************
	; Warteschleife 250 ms
	; Wait250
        movlw   D'250'          ; 250 ms Pause
        movwf   loops 
		goto Wai
			
	;*********************************************************	
Wai
        movlw   .110           	;Zeitkonstante für 1ms
        movwf   loops2			;inizialisieren von loops2
Wai2    nop 
        nop
        nop
        nop
        nop
        nop
        decfsz  loops2, F      ; 1 ms vorbei?
        goto    Wai2           ; nein, noch nicht
                               ;
        decfsz  loops, F       ; 250 ms vorbei?
        goto    Wai            ; nein, noch nicht
        retlw   0              ; das Warten hat ein Ende
		
;*************************************************************************
;Hauptprogramm
main
		; call    0x3FF             ; retrieve factory calibration value
		; bsf     STATUS,RP0        ; set file register bank to 1 
		; movwf   OSCCAL            ; update register with factory cal value 
		; bcf     STATUS,RP0        ; set file register bank to 0
		
	; bcf GPIO,4					;Erst mal alles Ausschalten
	; bcf GPIO,5					;Erst mal alles Ausschalten
	clrf	GPIO
		
	BTFSC GPIO,2	;Endschalter abfragen 	Wenn Eingang auf Masse dann übergehen
	bcf GPIO,5		;PIN 5 ist auf PLUS		(Wenn Eingang auf 1 dann Pin 5 auf Plus)
	BTFSC GPIO,3	;Endschalter abfragen 	Wenn Eingang auf Masse dann übergehen
	bsf GPIO,5		;PIN 5 ist auf Masse	(Wenn Eingang auf 1 dann Pin5 auf Masse)
	;****************************links herum*********************************	
	BTFSC 	GPIO,0		;wenn der Eingang 1 ist, Links herum einschalten
	call prüfen
	BTFSS 	GPIO,0		;Wenn der Eingang 0 ist 
	call inilinks		;Endwert und Merker wieder auf Anfang setzen
		
	;*************************** rechts herum *******************************
	BTFSC 	GPIO,1      ;wenn der Eingang 1 ist, Rechts herum einschalten
	call prüfenrechts
	BTFSS 	GPIO,1		;Wenn der Eingang 0 ist 
	call inirechts		;Endwert und Merker wieder auf Anfang setzen
	goto main			


; initialize eeprom locations

		ORG	0x2100
		DE	0x00, 0x01, 0x02, 0x03


		END                       ; directive 'end of program'

[PsiQ]

Alsoooo.
Das ist evtl etwas ketzerisch jetzt die ganze schöne Software wieder zu entfernen, ABER:

Du gibst doch per Software die Drehrichtung vor, an Pin5.
Dann brauchst du keine 2 Eingänge für Endschalter verwenden, sondern kannst beide per (evtl mit 1k dazwischen) (o.ä.) auf einen Eingang legen.
Nehmen wir mal Pin2 = Stopp
Welcher Endschalter grad klingelt, weisst du ja von Pin5.

Wenn Pin5 LOW
und
"Stopp"signal => Rechtsrum stoppen

Wenn
Pin 5 HIGH
und
"Stopp"signal
=> Linksrum stoppen

Oder einfach den Ausgang 4 deaktiveren (bis taster losgelassen; subroutine intern zum Ende hin überspringen),
dann ist die Drehrichtung Pin5 egal und muss nicht ausgewertet werden.

Damit hast du Pin3 frei,
und kannst diesen als "Turboknopf" verwenden.

Gleiches spiel wäre bei Pin1+2 möglich:
Wenn es einen ADC oder "float*"(?) Pin gibt. *mit "float" meine ich, er hängt ohne signal oder per 10k:10k Spannungsteiler auf ca 2,5V und erkennt high oder low als signal)
Nimm einen Wechseltaster oder Schalter
(1)/0/(1) => ( ) = Tastfunktion; 0 = Ruhestellung
Wenn der Schalter in Mittelstellung ist liegen über einen 10k:10k Spannungsteiler 2,5V am Pin an.
Wenn er links oder rechts gedrückt wird brückt der Taster nach 0V oder 5V. => links/rechts drehen.

Wenn der Chip nen ADC hat, kannst du sogar ein Poti nehmen, und je nach Auslenkung aus der Mittelstellung (mit etwas totbereich 2V..3V),
und damit direkt die Geschwindigkeit proportional dem Ausschlag machen, wie bei ner Modellbausteuerung.

PS.: Quellcode:
Fehlt nach "call init" nicht in
"init"
ein return am Ende ??
Der rasselt da nach "init" doch ins unterprogramm "prüfen" weiter,
und dort steht dann (erst) ein "return", oder ist das Absicht?

Ich würde da
"call init" ... "return"
"call prüfen" ... "return"
[weiter im Programm]
machen.

Dann sieht man oben besser wie die einzelnen Schritte abgearbeitet werden.

Wenn du mit 100nF 100k gemeint hast, kannst du versuchen mal 20k als pulldown oder pullup zu verwenden.
oder ein Entstörglied als Kombination aus 1k + 100nF vor dem Eingangspin setzen.

Am µC hast du direkt nen 100nF ?








-------------------
Alternative ohne ADC / float:
Pin0 - Drehrichtung: HIGH = rechtsrum, LOW = linksrum => KippSCHALTER 1/1 (Pin0 + 20k Widerstand + daran den mittleren Pin vom Kippschalter)
Pin1 - langsam drehen : 20k Pulldown nach Gnd, Taster mit 1k nach +5V => LOW = nichtstun; HIGH (Taster gedrückt) = langsam drehen
Pin2 - schnell drehen : 20k Pulldown nach Gnd, Taster mit 1k nach +5V => Low = nichtstun; HIGH (Taster gedrückt) = schnell drehen
Pin3 - Beide Endschalter (HIGH oder LOW als Stoppsignal je nach Geschmack und el. Schaltung)
Pin4 - Ausgang Impulse (deaktiveren / subroutine übersrpingen bei "Stopp")
Pin5 - Ausgang Drehrichtung

edit: Pin0 und Pin5 haben hier das gleiche Signal! -Wenn du bei Pin0 einen Kippschalter 1/1 verwendest,
brauchst du Pin5 nichtmehr und der wäre frei!! (Für ultraschnell oder anfahren der mittelstellung odersowas)
Bisschen mehr Hardware...