PIC-Würfel: Interrupt, Timer1 und Sleep Mode

[P.H.]

Hallo liebe Nutzergemeinschaft,

wir befinden uns in unserer Ausbildung momentan in einem Stadium der
Verzweiflung. Mein Kollege und ich scheitern schon lange an einem
Würfel, wobei unser Ausbilder immer wieder mit neuen Aufgaben zu uns
kommt. Jetzt sollen noch der Sleep Mode, Interrupts und eine Abfrage
anhand einer fallenden Flanke erfolgen. Ich hoffe ihr könnt uns helfen,
damit wir das Projekt abschliessen können. Wir nutzen den PIC12F675.
Vergebt mir meine etwas schlechte Programmierarbeit, aber ich wusste
nicht wie ich es anders realisieren soll.
Wir benutzen einen Neigungswinkelschalter, um ein richtiges
Würfelfeeling hinzubekommen.Der Sleep Mode soll mit Hilfe des Timer1
aktiviert werden, und durch eine Flanke an GP5 im Sleep Mode wieder
aufgeweckt werden.

Code:

;********************************************************************

;Projekt:  PIC-gesteuerter Würfel
;Funktion: Zufällige Zahl von Eins bis Sechs ausgeben
;Autor:    Philipp Hess

;***************************Variablen**************************************

Takt equ .4000000
Zaehler equ 0x23
Counter1 equ 0x24
Counter2 equ 0x25
Counter3 equ 0x26

;**************************************************************************

Konfiguration:

errorlevel -302
list p=12F675
#include <p12f675.inc>
__CONFIG    _CP_OFF & _WDT_OFF & _BODEN_ON & _INTRC_OSC_NOCLKOUT & _CPD_OFF & _PWRTE_ON & _MCLRE_OFF

Start

banksel CMCON ; Bankauswahl CMCON
movlw B'00000111' ; Analog-Komparator aus
movwf CMCON ; Komparator Steuerregister
banksel TRISIO ; Bankauswahl TRISIO
movlw B'11101000' ; Defintion der IO-Ports
movwf TRISIO ;  " " "
banksel GPIO ; Bankauswahl GPIO
clrf GPIO ; Löschen der Vorgeschichte

Lauflicht

movlw B'11010110' ; Würfelzahl 1
movwf GPIO ; Ausgabe
call Verzoegerung_1s ; Zeitschleife 1s
movlw B'11010101' ; Würfelzahl 2
movwf GPIO
call Verzoegerung_1s
movlw B'11010100' ; Würfelzahl 3
movwf GPIO
call Verzoegerung_1s
movlw B'11010001' ; Würfelzahl 4
movwf GPIO
call Verzoegerung_1s
movlw B'11010000' ; Würfelzahl 5
movwf GPIO
call Verzoegerung_1s
movlw B'11000001' ; Würfelzahl 6
movwf GPIO
call Verzoegerung_1s
movlw B'11000000' ; Alle LED's an (=7)
movwf GPIO
call Verzoegerung_1s
movlw B'11010111' ; Alle LED's aus (=0)
movwf GPIO

Main

btfsc GPIO, GP5 ; Neigungswinkelschalter ueberpruefen
goto Main ; Wenn der Schalter nicht betätigt wurde, startet der Würfel nicht

Laden

movlw B'00000110' ; Wert ins W-Register laden
movwf Zaehler ; W-Register in Zaehler-Speicherzelle schreiben

Herunterzaehlen

btfsc GPIO,GP5 ; Tasterstand überprüfen
goto Funktionstest ; Sprung zu "Funktionstest"
decfsz Zaehler,F ; Speicherzelle "Zaehler" dekrementieren
goto Herunterzaehlen ; Sprung nach Schleifenanfang
goto Laden ; Wenn Zaehler =0, Sprung zu "Laden"

;**************************************************************************

Funktionstest
  
btfss GPIO,GP5 ; Tasterstand überprüfen
goto Funktionstest ; Sprung nach Schleifenanfang
call Verzoegerung_2s ; Zeitschleife 2s

Würfelausgabe

movlw B'11010110' ; Würfelzahl 1
movwf GPIO ; Ausgabe
call Verzoegerung_250ms ; Zeitschleife 250ms
movlw B'11010101' ; Würfelzahl 2
movwf GPIO
call Verzoegerung_250ms
movlw B'11010100' ; Würfelzahl 3
movwf GPIO
call Verzoegerung_250ms
movlw B'11010001' ; Würfelzahl 4
movwf GPIO
call Verzoegerung_250ms
movlw B'11010000' ; Würfelzahl 5
movwf GPIO
call Verzoegerung_250ms
movlw B'11000001' ; Würfelzahl 6
movwf GPIO
call Verzoegerung_250ms
movlw B'11000000' ; Alle LED's an (=7)
movwf GPIO
call Verzoegerung_1s
movf Zaehler,W ; Wert Zaehler-Speicherzelle ins W-Register
addlw -1 ; Addiere -1
call Tab1 ; Rufe Unterprogramm "Tab1" auf
movwf GPIO ; Ausgabe an GPIO
goto Tastentest ; Sprung zu "Tastentest"

;**************************************************************************

Tastentest

call Verzoegerung_2s
call Verzoegerung_3s ; Zeitschleife 5s
goto Löschen ; Sprung zu "Löschen"

Auswahl

btfss GPIO, GP5 ; Tasterstand überprüfen
goto Neuer_Ladevorgang ; Sprung zu "Neuer_Ladevorgang"
goto Löschen ; Sprung zu "Löschen"

Neuer_Ladevorgang

movlw B'00000110' ; Wert ins W-Register laden
movwf Zaehler ; W-Register in Zaehler-Speicherzelle schreiben

; Hier soll die Flanke abgefragt werden, anstatt eines Zustandes

Neu_Würfeln

btfss GPIO, GP5 ; Tasterstand überprüfen
goto Decrement ; Sprung zu "Decrement"
goto Funktionstest ; Sprung zu "Funktionstest"

Decrement

call Tab1 ; Rufe Unterprogramm "Tab1" auf
decfsz Zaehler, F ; Speicherzelle "Zaehler" dekrementieren
goto Neu_Würfeln ; Sprung zu "Neu_Würfeln"
goto Neuer_Ladevorgang ; Sprung zu "Neuer_Ladevorgang"

Löschen

movlw B'11010111' ; Wert ins W-Register laden
movwf GPIO ; Alle LED's aus
goto Main ; Sprung zu "Laden"

Tab1

addwf PCL, F
DT   0xFE, 0xFD, 0xFC, 0xF9, 0xF8, 0xE9
return

;**************************************************************************

Verzoegerung_250ms:

  movlw    D'60'
  movwf    Counter1
  movlw    D'67'
  movwf    Counter2
  movlw    D'1'
  movwf    Counter3
  nop
  nop
  call     Verzoegerung_mittel_5
  call     Verzoegerung_lang_5
  return

Verzoegerung_mittel_5:

Verz_mittel_1_5:

  decfsz   Counter1,F
  goto     Verz_mittel_1_5

Verz_mittel_2_5:

  decfsz   Counter1,F
  goto     Verz_mittel_2_5
  nop
  decfsz   Counter2,F
  goto     Verz_mittel_2_5
  return

Verzoegerung_lang_5:

Verz_lang_1_5:

  decfsz   Counter1,F
  goto     Verz_lang_1_5
  nop
  decfsz   Counter2,F
  goto     Verz_lang_1_5
  nop

Verz_lang_2_5:

  decfsz   Counter1,F
  goto     Verz_lang_2_5
  nop
  decfsz   Counter3,F
  goto     Verz_lang_1_5
  return

Verzoegerung_1s: ; Zeitschleife 1s

    movlw   D'0'
    movwf   Counter1
    movlw   D'11'
   movwf   Counter2
   movlw   D'5'
   movwf   Counter3
   nop
   call   Verzoegerung_mittel
   call   Verzoegerung_lang
   return

Verzoegerung_mittel:

Verz_mittel_1:

    decfsz Counter1,F
    goto   Verz_mittel_1

Verz_mittel_2:

    decfsz  Counter1,F
    goto   Verz_mittel_2
    nop
    decfsz Counter2,F
    goto   Verz_mittel_2
    return


Verzoegerung_lang:

Verz_lang_1:

decfsz Counter1,F
   goto   Verz_lang_1
   nop
   decfsz  Counter2,F
   goto   Verz_lang_1
   nop

Verz_lang_2:

   decfsz Counter1,F
   goto    Verz_lang_2
   nop
   decfsz  Counter3,F
   goto    Verz_lang_1
   return

;**************************************************************************

Verzoegerung_2s: ; Zeitschleife 2s

    movlw   D'3'
    movwf   Counter1
    movlw   D'24'
   movwf   Counter2
   movlw   D'10'
   movwf   Counter3
   nop
   call    Verzoegerung_mittel_1
   call    Verzoegerung_lang_1
   return

Verzoegerung_mittel_1:

Verz_mittel_1_1:

    decfsz  Counter1,F
    goto    Verz_mittel_1_1

Verz_mittel_2_1:

    decfsz Counter1,F
    goto    Verz_mittel_2_1
    nop
    decfsz  Counter2,F
    goto    Verz_mittel_2_1
    return

Verzoegerung_lang_1:

Verz_lang_1_1:

decfsz  Counter1,F
   goto    Verz_lang_1_1
   nop
   decfsz Counter2,F
   goto   Verz_lang_1_1
   nop

Verz_lang_2_1:

   decfsz  Counter1,F
   goto    Verz_lang_2_1
   nop
   decfsz  Counter3,F
   goto    Verz_lang_1_1
   return

;**************************************************************************

Verzoegerung_3s: ; Zeitschleife 3s
 
movlw   D'8'
    movwf   Counter1
movlw   D'36'
   movwf   Counter2
   movlw   D'15'
   movwf   Counter3
   call    Verzoegerung_mittel_1_1
   call    Verzoegerung_lang_1_1
   return

Verzoegerung_mittel_1_1:

Verz_mittel_1_1_1:

  btfss GPIO, GP5
goto Auswahl
decfsz  Counter1,F
    goto    Verz_mittel_1_1_1

Verz_mittel_2_1_1:

btfss   GPIO, GP5
goto Auswahl
   decfsz  Counter1,F
   goto    Verz_mittel_2_1_1
   nop
   decfsz  Counter2,F
   goto    Verz_mittel_2_1_1
   return

Verzoegerung_lang_1_1:

Verz_lang_1_1_1:

btfss GPIO, GP5
goto    Auswahl
decfsz  Counter1,F
   goto    Verz_lang_1_1_1
   nop
   decfsz  Counter2,F
   goto    Verz_lang_1_1_1
   nop

Verz_lang_2_1_1:

btfss GPIO, GP5
goto Auswahl
   decfsz  Counter1,F
   goto    Verz_lang_2_1_1
   nop
   decfsz  Counter3,F
   goto    Verz_lang_1_1_1
   return

;**************************************************************************

END

[P.H.]

Hier noch ein Bild der Schaltung, zum Verständnis warum wir '0' statt '1' genutzt haben.

[P.H.]

http://tinypic.com/view.php?pic=mkaow&s=7

[Edson]

Hallo Philipp,

um es gleich vorweg zu nehmen: Ohne eine konkrete Fragestellung wirst du hier kaum Unterstützung finden. Es ist lobenswert dass du von Anfang an zugibst dass du/ihr diese Aufgabe selber lösen sollt - das solltet ihr dann aber auch wirklich tun. Das Mindeste ist es, ein konkretes Problem anzusprechen und zu erklären womit ihr Probleme habt. Kaum jemand ist bereit, den Quelltext durchzuackern und die fehlenden Programmteile aus purer Lust gleich mitzuliefern. Also, stell bitte eine konkrete Frage dann bekommst du auch Unterstützung.

Viele Grüße,
Edson

[Stephan]

Zumal das ganze schon auf http://www.mikrocontroller.net/topic/209387 durchgekaut wurde.

[P.H.]

Unser konkretes Problem ist, dass wir um ehrlich zu sein keine Ahnung haben wie wir den Sleep Mode in abhängigkeit vom Timer1 aktivieren können und danach durch einen ION an GP5 wieder beenden (aufwachen) können, da wir die Themen noch nicht in der Schule durchgesprochen haben. Auf Mikrocontroller.net wurde ich auf ein Forum verwiesen, welches sich mehr auf PIC's anstatt auf AVR's spezifiziert.

Ich hab nur gehofft, dass uns eventuell jemand bei unserem Problem, durch Erweiterung unseres Codes helfen kann.

[Stephan]

Du willst den SLEEP in Abhängigkeit vom Timer1 aktivieren und durch GP5 wieder beenden??? Das verstehe ich nicht. SLEEP wird durch den SLEEP-Befehl aktiviert, nicht durch einen Timer. Du kannst durch Timer1 wieder aufwachen lassen oder durch einen Pin (z.B. GP5).

Aufwachen ohne Interrupt: INTCON/GIE darf nicht gesetzt werden
Aufwachen mit Interrupt: INTCON/GIE muss gesetzt werden

Aufwachen durch Timer1: INTCON/PEIE und PIE1/TMR1IE muss gesetzt sein
Aufwachen durch GPx: INTCON/PEIE und INTCON/GPIE muss gesetzt sein

Datenblatt: page 15-16

Die Banks, in denen die Register stehen, müsst Ihr noch selbst setzen.

Code:

; im init
    clrf   INTCON
    bsf    INTCON, PEIE      ; periphere Interrupts erlauben
    clrf   PIE1
    bsf    PIE1, TMR1IE      ; Timer1 Interrupt enable

...

; im main
    sleep                    ; wenn Timer1 überläuft, wird sleep beendet
    nop                      ; nach sleep 1x nop !
    bcf   PIR1, TMR1IF       ; Timer 1 flag bit rücksetzen

Den Code für Aufwachen durch GPx könnt Ihr analog zusammenbasteln.

[Stampede]

Hi Philipp,

erstmal herzlich willkommen im Forum.

Ich verstehe die Frage auch nicht 100%, ich gehe aber mal davon aus, dass ihr beabsichtigt, mit dem Sleep Modus Strom zu sparen und die Batterielaufzeit zu maximieren. Daher paar Anregungen von mir:

Der Sleep Modus wird, wie Stephan schon gesagt hat, mit dem Sleep Befehl aktiviert. Prinzipiell ist es so, dass jeder Interrupt den PIC wieder aus dem Schlaf holen kann. Abhaenig davon, wie die Bits im INTCON gesetzt sind, wird in eine Interuptroutine gesprungen (INTCON, GIE = 1)oder mit dem Befehl nach dem Sleepkommando (INTCON, GIE = 0) weitergearbeitet. Was nun in eurem Falle besser ist, koennt ihr entscheiden.

Da ihr je eine batteriebetriebene Schaltung habt, ist Stromsparen extrem wichtig. Wenn ihr euch mal euren Code anschaut, muesste euch doch sofort auffallen, dass der PIC den Taster abfragt, und den Rest der Zeit mit 4MHz durch die Warteschleife rennt, die mit den dreifach geschachtelten Loops einfach nur grauenhaft ist.
Daher: Reduziert die Taktfrequenz des PIC. Fuer diese Appilaktion sind 250kHz locker ausreichend (ggf sogar weniger).  Dann koennen die Warteschleifen mit weniger Instruktionen realisiert werden, das spart Code und Strom.
Man kann es aber auch noch weiter treiben: Die Warteschleife ueber einen Timer realisieren der den PIC per Interrupt aus dem Schlaf holt. Wenn euch das zu viel arbeit bereiten sollte (waere aber die eleganteste Moeglichkeit), koennte man alternativ fuer die Warteschleife den 31kHz Oszi benutzen um den Sttromverbrauch in der Zeit zu minimieren.
Ausserdem: 3 Wartescheifen fuer 1, 2 und 3 Sekunden? Ruft doch die Zeitschleife fuer 1 Sekunde doch einfach mehrmals hintereinander auf.

Wie genau hat ihr die Zufallsfunktion realisiert? Sehe das in eurem Code gerade nicht...

Gruesse,
Stefan

[P.H.]

Erstmal Danke für den Beitrag.

Die konkrete Frage ist, wie die Bits zu setzen sind, um den Timer1 zu aktivieren, und ihn so lange laufen zu lassen, solange nichts passiert und bei Überlauf den Sleep Mode zu aktivieren. Dasselbe beim Interrupt.

Die Zeitschleifen sind so gewählt, da unser Ausbilder immer wieder andere Abstände zwischen dem Blinken einzelner LED's haben will und wir eine Tasterstandabfrage während der 3 Sekündigen Warteschleife brauchen.

Die Zufallsfunktion befindet sich hier:

Code:

Laden

movlw B'00000110' ; Wert ins W-Register laden
movwf Zaehler ; W-Register in Zaehler-Speicherzelle schreiben

Herunterzaehlen

btfsc GPIO,GP5 ; Tasterstand überprüfen
goto Funktionstest ; Sprung zu "Funktionstest"
decfsz Zaehler,F ; Speicherzelle "Zaehler" dekrementieren
goto Herunterzaehlen ; Sprung nach Schleifenanfang
goto Laden ; Wenn Zaehler =0, Sprung zu "Laden"

Das Register "Zaehler" wird immer weiter runtergezählt, bis der Schalter betätigt wurde. Sollte er den Wert 0 erreichen, wird er wieder neu geladen und es geht von Vorne los.

[Stephan]

> Prinzipiell ist es so, dass jeder Interrupt den PIC wieder aus dem Schlaf holen kann. Abhaenig davon,
> wie die Bits im INTCON gesetzt sind, wird in eine Interuptroutine gesprungen (INTCON, GIE = 1)oder
> mit dem Befehl nach dem Sleepkommando (INTCON, GIE = 0) weitergearbeitet.

Das ist nicht ganz korrekt. Wenn der PIC in den SLEEP geht, wird immer noch der dem SLEEP folgende Befehl in den Kern geladen und nach dem Aufwachen ausgeführt, AUCH WENN EIN INTERRUPT ERFOLGT: der PIC führt also den Folgebefehl aus und springt erst dann in den Interrupt. Es KANN aber sein, dass dies unerwünscht ist; es empfiehlt sich daher dann ein NOP nach dem SLEEP einzufügen. Ohne Interrupt ist es unerheblich. Ich habe mir das aber aus Bequemlichkeit generell angewöhnt.

[Hesselhoff]

Ich hab mich dann doch der Einfachheit halber registriert

Also wäre es praktisch möglich den Code so zu schreiben:

Code:

Main

Sleep
nop
nop                                                 ; 2 NOP's zur Sicherheit
btfsc GPIO, GP5 ; Neigungswinkelschalter ueberpruefen
goto Main ; Wenn der Schalter nicht betätigt wurde, startet der Würfel nicht

Dann wäre nur noch das Problem mit der Interruptroutine, da ich jetzt noch verwirrter bin als vorher welches Bit wie zu setzen ist. Der Interrupt sollte durch einen IOC an GP5 erfolgen. Muss ich dann vorher noch das Bit, das durch ihn gesetzt wird löschen? Also bevor der Sleep Mode aktiviert wird? Und muss noch was am Schaltplan geändert werden ( Siehe oben)?

[Stephan]

Code:

Sleep
nop
nop              ; 2 NOP's zur Sicherheit
btfsc GPIO, GP5    ; Neigungswinkelschalter ueberpruefen
goto Main      ; Wenn der Schalter nicht betätigt wurde, startet der Würfel nicht

neinnein, so geht das nicht. Wenn der Schalter nicht betätigt wurde, wacht der PIC nicht auf (es sei denn durch ein anderes Ereignis). Dann macht die Abfrage auch keinen Sinn.

Wenn der PIC durch eine Pinänderung aufwachen soll, dann muss das so aussehen:

Code:

; in der Initialisierung erst mal Interrupts konfigurieren
    bsf INTCON, GIE    ; erlaube alle Interrupts
    bsf INTCON, PEIE   ; erlaube externe Interrupts
    bsf INTCON, GPIE   ; erlaube Aufwachen durch



; im Programm
    sleep              ; PIC legt sich schlafen und wacht durch Änderung an GPx auf
    nop                ; 1 NOP reicht
; hier springt der PIC in den Interrupt und macht das, was der Int. machen soll,
; kehrt danach hierher zurück

; hier gehts dann mit dem Programm weiter

Den Programmteil mit der Pinabfrage kannst Du Dir dann sparen, das macht der PIC automatisch, da er ja durch die entsprechende Initialisierung dazu programmiert wurde.

[P.H.]

Weil ich mich aus irgendwelchen Gründen nicht einloggen kann nochmal so.

Hab jetzt die Interruptroutine reingenommen, und jetzt sollte wenn sich irgendein Pin ändert ein Interrupt ausgelöst werden, der den Sleep Mode beendet? Hab ich das richtig verstanden?

Ich versetze jetzt meinen PIC nach dem erstem Lauflicht in den Sleep Mode:

Code:

; Lauflicht

Sleep

  sleep
  nop

Main

  ...

Und meine Initaliserung sieht jetzt so aus:

Code:

banksel CMCON ; Bankauswahl CMCON
movlw B'00000111' ; Analog-Komparator aus
movwf CMCON ; Komparator Steuerregister
banksel TRISIO ; Bankauswahl TRISIO
movlw B'11101000' ; Defintion der IO-Ports
movwf TRISIO ;   " " "
banksel INTCON
    bsf INTCON, GIE    ; erlaube alle Interrupts
    bsf INTCON, PEIE  ; erlaube externe Interrupts
    bsf     INTCON, GPIE    ; erlaube Aufwachen durch
banksel GPIO ; Bankauswahl GPIO
clrf GPIO ; Löschen der Vorgeschichte

Und nochwas: Hab den MCLR als Input Pin kofiguriert. Muss er jetzt noch mit Vcc auf High Pegel gezogen werden, um den Sleep Mode aktivierbar zu machen?

[tt2t]

> Und nochwas: Hab den MCLR als Input Pin kofiguriert. Muss er jetzt noch
> mit Vcc auf High Pegel gezogen werden, um den Sleep Mode aktivierbar zu
> machen?

MCLR kann ausschliesslich als Input fungieren (je nach CONFIG-Bits als Reset oder als normaler Input).

Was macht denn eigentlich der Interrupt, ich kann in Deinem Code keinen Intterrupt finden?

[Stephan]

MCLR/GP3 hat keinen internen pullup (bei GP0-GP2,GP4-GP5 kann der interne pullup aktiviert werden).

Nochmals zu Deinem Programm: die Warteschleifen sind ein Chaos! Mach 1 (eine) Warteschleife und rufe die ggf. mehrfach auf, das spart enorm Programmspeicher.