;----------------------------------------------------------------------
; Würfelsimulator mit ATTiny13 / ATTiny13V
; Weitere Infos: www.schramm-software.de/bausatz/
;----------------------------------------------------------------------
; Prozessor: ATtiny13 (V)
; Takt : 128 kHz
; Sprache : Assembler
; Version : 1.0
; Autor : Dr. Michael Schramm
; Datum : 5.2009
;----------------------------------------------------------------------
; Portbelegung:
; PB0: Taster gegen Masse
; PB1 bis PB4: Leuchtdioden gegen Masse:
; 2 1
; 3 4 3
; 1 2
; PB5 wie PB1
;----------------------------------------------------------------------
.include "tn13def.inc"
; Als globale Variablen genutzte Register:
.DEF lfsr0 = r6 ;3 Register bilden ein 23bit-LFSR
.DEF lfsr1 = r7 ; (linear rückgekoppeltes Schieberegister)
.DEF lfsr2 = r8 ; für den Pseudo-Zufallszahlengenerator
.DEF ledmust = r9 ;PB-LED-Muster gemäß wuewert
.DEF int_lwr = r10 ;nur als Zwischenspeicher in Interrupt-Routinen
.DEF int_hir = r11 ;nur als Zwischenspeicher in Interrupt-Routinen
.DEF ausr_ct = r12 ;Ausroll-Counter (Zähler je Interrupt)
.DEF einsreg = r13 ;konstant 1
.DEF intreg = r14 ;nur als Zwischenspeicher in Interrupt-Routinen
.DEF nullreg = r15 ;konstant 0
.DEF tim24bt = r21 ;für 24bit-Timer-Zähler
.DEF ausr_ln = r22 ;Anz. Interrupts pro Ausrollschritt
.DEF wuewert = r23 ;gewürfelte bzw. anzuzeigende Zahl, als Index 0..5
.DEF phase = r24 ;Spielphase, steuert Vorgänge bei Timer-Interrupt:
; 0: nichts zu tun
; 1: gewürfelter Wert glimmt mehrfach auf (zeitlich zuletzt)
; 2: warten auf Tastendruck nach Einschalten, PB4-LED blinken lassen
; 3: Taste gedrückt beim Würfeln, "Würfel rollen lassen"
; 4: Taste losgelassen, "Würfel rollt aus"
.DEF flags = r25 ;diverse Flags. Bedeutung der Bits:
; 6: Interrupt durch gedrückte Taste
; 7: Tastendruck-Interrupt ausgelöst
;----------------------------------------------------------------------
.macro ldi_hl ;(reg, 16bit-Zahl)
ldi @0h,high(@1)
ldi @0l,low(@1)
.endmacro
.macro out_i ;(I/O-reg, 8bit-Zahl) - zerstört Inhalt von R16
ldi r16,@1
out @0,r16
.endmacro
.macro for ;(reg, anzahl bzw. startwert, label); für reg ab R16
ldi @0,@1
.set @2 = pc
.endmacro
.macro next_down ;(reg, label)
dec @0
.if pc-@1 < 64
brne @1
.else
breq pc+2
rjmp @1
.endif
.endmacro
.macro next_up ;(reg, endwert, label)
inc @0
cpi @0,@1+1
.if pc-@1 < 64
brcs @2
.else
brcc pc+2
rjmp @2
.endif
.endmacro
.macro loop ;(label, reg) - Register muss vorbelegt sein
.set @0 = pc
.endmacro
;----------------------------------------------------------------------
.CSEG
;Reset- und Interruptvektoren
rjmp start ;0 RESET, Brown-out Reset, Watchdog Reset
reti ;1 INT0 External Interrupt Request 0
rjmp i_pcint0;2 PCINT0 Pin Change Interrupt Request 0
rjmp i_t0ov ;3 TIM0_OVF Timer/Counter Overflow
reti ;4 EE_RDY EEPROM Ready
reti ;5 ANA_COMP Analog Comparator
reti ;6 TIM0_COMPA Timer/Counter Compare Match A
rjmp i_t0cmb ;7 TIM0_COMPB Timer/Counter Compare Match B
; reti ;8 WDT Watchdog Time-out
; reti ;9 ADC ADC Conversion Complete
;----------------------------------------------------------------------
led_kombi: ;LED-Kombinat. der Würfelzahlen für PORTB, mit PB0-Pull-Up
; Reihenfolge der Würfelzahlen: 1 6 2 5 3 4
.db 0b010001,0b101111,0b100101,0b110111,0b110101,0b100111

start:
; zunächst Stromsparmaßnahmen und Initialisierung
ldi r16,0b111110
out DIDR0,r16 ;Port-B-Input-Buffer ausschalten
out DDRB, r16 ;Datenrichtung von Port B
sbi ACSR,ACD ;Analog-Comparator ausschalten
clr einsreg
inc einsreg ;einsreg (R13) bleibt dauerhaft 1
out PORTB,einsreg ;Pull-Up-Widerstand an PB0 aktivieren
clr nullreg ;nullreg (R15) bleibt dauerhaft null
clr phase ;Timer-Overflow-Interrupt soll zunächst nichts tun
mov lfsr2,r16
out_i SPL,low(RAMEND) ;Stackpointer setzen, 8bit-Pointer bei Tiny13
mov lfsr0,r16
clr lfsr1 ;die LFSR-Register initialisieren
clr flags
clr wuewert
sei ;Interrupts erlauben
out_i PCMSK,(1<<PCINT0) ;Pin-Change an Pin PB0 beobachten
; nach dem Einschalten kurz alle LEDs leuchten lassen
rcall wait500ms ; eine halbe Sekunde warten
out_i PORTB,0b111111 ; alle LEDs an und Pull-Up-Widerstand
rcall wait500ms ; ... für eine Sekunde, Zeit zum Messen
rcall wait500ms
;----------------------------------------------------------------------
spiel:
; Nun warten, bis die Taste gedrückt wird. Falls das nicht innerhalb
; von etwa 4 Sekunden geschieht (xh = 8), in den Demo-Modus wechseln.
; sbi PCMSK,(1<<PCINT0) ;Signale an PB0 sollen Interr. auslösen können
out PORTB,einsreg ; alle LEDs wieder aus
sbis PINB,0 ;Taste bereits gedrückt?
rjmp taste_gedr ;dann keine Wartephase
ldi phase,2 ;zentrale LED soll blinken
rcall wait_taste
sbrs flags,7 ;Tasten-Interrupt?
rjmp demomodus ;nein => in den Demo-Modus wechseln

taste_gedr:
; Messen, wie lange die Taste gedr. wird.
; Unter 4 Sekunden => normales Spiel, Drückzeit bestimmt Würfelzahl
; 4 bis 8 Sekunden => Demo-Modus mit zufälligem Einstieg
; Über 8 Sekunden => 1-kHz-Signalerzeugung
ldi phase,3 ;schnell wechselnde Würfelzahlen zeigen
rcall wait_taste ;max. 4 Sek. auf Taste-Loslassen warten
sbrc flags,7 ;Tasten-Interrupt?
rjmp zeitmod6 ;ja => aus der Drückzeit den Würfelwert ermitteln
; 4 Sekunden sind verstrichen, Taste ist noch gedrückt. Weiter messen.
out PORTB,einsreg ;alle LEDs aus
clr phase ;im Timer-Overflow-Interrupt nichts mehr tun
rcall wait_taste ;weitere max. 4 Sek. auf Taste-Loslassen warten
sbrs flags,7 ;Tasten-Interrupt?
rjmp khz_signal ;nein, volle 8 Sek. verstrichen => Signalerzeugung
; Es soll der Demo-Modus mit zufälligem Würfelsequenz-Startpunkt
; beginnen. Gemessene Tastendruckzeit als Zufallswert nutzen.
movw lfsr0,x ;Tastendruckzeit als Zufallsgenerator-Startwert
mov lfsr2,einsreg ; lfsr insgesamt darf niemals 0 sein
;----------------------------------------------------------------------
demomodus: ;Dauer-Würfeln ...
; Falls Taste gedrückt, wieder normales Spiel
rcall init_pcif ;Tastendruck soll erkannt werden
demo_lp:
rcall wait500ms ; 1/2 Sekunde warten
ldi phase,3 ;schnell wechselnde Würfelzahlen zeigen
rcall set_tim_2khz ;Timer starten
ldi r16,(1<<SE)
demo_schnell: ;schneller Zahlenwechsel, "Würfel rollt"
out MCUCR,r16 ;Idle-Modus
sleep ;CPU schläft, wartet auf Interrupt (Timer/Taste)
sbrc flags,7 ;Tasten-Interrupt?
rjmp spiel ;ja => hier abbrechen, normales Spiel beginnen
cpi xh,16 ;etwa 2 Sekunden schnelles Würfelrollen
brcs demo_schnell
demolp2:
ldi xl,5
rcall zufallszahl ;Pseudo-Zufallszahl generieren
andi xl,7 ;die letzten drei Bits isolieren, also Werte 0 ... 7
cpi xl,6 ;nur Werte 0 .. 5 akzeptieren
brcc demolp2 ;ggf. neue Zuf.zahl erzeugen, so Gleichverteilung 0..5
cp xl,wuewert ;gleiche Werte direkt nacheinander ...
ldi wuewert,-1 ;sollen nur selten auftreten
breq demolp2
mov wuewert,xl
rcall wuerfeln ;Würfel ausrollen und Ergebnis zeigen
sbrs flags,7 ;Tasten-Interrupt?
rjmp demo_lp ;nein => weitermachen im Demo-Modus
rjmp spiel ;ja => normales Spiel beginnen
;----------------------------------------------------------------------
zeitmod6: ;Drückzeit (in XH:XL) modulo 6 berechnen ("Zufallszahl")
tst xh ;sehr kurze Drückzeit (< 128 ms)
breq spiel ;nicht akzeptieren
; add xl,yl ;letzten Messwert dazuzählen, um Manipulation
; adc xh,yh ;zu erschweren
; movw y,z ;merken für die nächste Runde
rcall xmod6 ;Ergebnis in wuewert
rcall wuerfeln ;Würfel ausrollen und Ergebnis zeigen
sbrc flags,7 ;Tasten-Interrupt?
rjmp spiel ;ja => sofort nächstes Spiel starten
schlafen:
; Ende der Würfelrunde, schlafen gehen
rcall init_pcif ;Pin-Change-Interrupt einschalten
out_i MCUCR,(1<<SE)+(1<<SM1) ;Power-down-Modus
sleep ;Tiefschlaf, warten auf Interrupt (Tastendruck)
rjmp spiel ;nächstes Würfeln starten
;----------------------------------------------------------------------
khz_signal: ; 1-kHz-Signal an PB2 und PB1 (gegenläufig) erzeugen
; Abbruch, sobald Taste gedrückt wird; dann normales Spiel starten
out_i PORTB,0b101 ; alle LEDs bis auf die an PB2 aus
ldi r18,0b110 ; 1-Bits schalten um bei OUT
khz_weiter:
rcall init_pcif ;Pin-Change-Interrupt einschalten
khz_loop:
for r19,20,khz_wt ;Warteschleife für knapp 1/2 ms
next_down r19,khz_wt
out PINB,r18 ; PB2 und PB1 umschalten
sbrs flags,7 ;wurde Tastenflag gesetzt (durch Interrupt)?
rjmp khz_loop ; nein: weiterhin Signal erzeugen
sbrs flags,6 ;Taste erst einmal losgelassen oder neu gedrückt?
rjmp khz_weiter ;losgelassen: weiterhin Signal erzeugen
rjmp spiel ; neu gedrückt: wieder normales Spiel
;----------------------------------------------------------------------
; ******************* Unterprogramme / Funktionen *******************

wuerfeln: ; *** Würfel ausrollen und Zahl gemäß Register wuewert zeigen
push wuewert
ldi phase,4 ;steht für Ausrollen
ldi ausr_ln,2 ;zunächst eine Zahl pro 2 Interrupts anzeigen
mov ausr_ct,ausr_ln
rcall set_tim_2khz ;Timer mit 2 kHz-Takt starten
ldi r16,(1<<SE)
wuerf_ausr: ;Ausroll-Anzeige regelt der Timer-Overflow-Interrupt
out MCUCR,r16 ;Idle-Modus
sleep ;CPU schläft, wartet auf Interrupt (Timer-Overflow)
cpi xh,13 ;Ausrollen abgeschlossen?
brcs wuerf_ausr ;nein, noch nicht
out TCCR0B,nullreg ;Timer aus
; ldi phase,1 ;Glühen/Dimmen des Würfelwertes
rcall init_pcif
ldi r16,2
ldi ausr_ln,1
mov ausr_ct,einsreg
for r19,5,wdimlp_
wdimlp:
mov r0,ausr_ln
wdimlp1:
sub r0,r16
brcc wdimlp1
out PORTB,ledmust
mov r0,ausr_ln
wdimlp2:
add r0,r16
brcc wdimlp2
out PORTB,einsreg
sbrc flags,7 ;Tasten-Interrupt?
rjmp wuerf_end ;ja => vorzeitig abbrechen
add ausr_ln,ausr_ct
cpi ausr_ln,255
breq wdim_cge
cpi ausr_ln,1
brne wdimlp
wdim_cge:
neg ausr_ct
next_down r19,wdimlp_
wuerf_end:
pop wuewert
ret
;----------------------------------------------------------------------
init_pcif: ; *** Pin-Change-Interrupt einschalten
cbr flags,(1<<7) ;Tastenflag löschen
ldi r16,(1<<PCIF)
; Das Pin-Change-Flag in GIFR muss zurückgesetzt werden, damit ein
; schon erfolgter Pin-Cge nicht im Nachhinein einen Interr. auslöst.
out GIFR,r16 ;Pin-Change-Flag löschen
out_i GIMSK,(1<<PCIE) ;Pin-Change-Interrupt aktivieren
ret
;----------------------------------------------------------------------
wait500ms: ; *** in etwa eine halbe Sekunde warten
; Stromsparende Realisierung über Timer im Sleep-Modus
out TCNT0,nullreg ;Counter-Wert nullsetzen
out_i TIMSK0,(1<<TOIE0) ;Timer-Overflow-Interrupt aktivieren
out_i TCCR0B,(1<<CS02) ;Timertakt = Systemtakt / 256 = 500 Hz
out_i MCUCR,(1<<SE) ;Idle-Modus
sleep ;CPU schläft, wartet auf Interrupt (Timer-Überlauf)
out TCCR0B,nullreg ;Timer stoppen
ret
;----------------------------------------------------------------------
wait_taste: ; *** auf Tastenereignis warten, jedoch max. ca. 4 Sekunden
; Output: XH:XL = verstrichene Zeit in 2000stel Sekunden
; flags-b7 gesetzt, falls Tastenereignis eingetreten
rcall init_pcif ;Pin-Change-Interrupt einschalten
rcall set_tim_2khz
ldi r16,(1<<SE)
wt_tas_4sek:
out MCUCR,r16 ;Idle-Modus
sleep ;CPU schläft, wartet auf Interr. (Taste oder Timer-Overflow)
sbrc flags,7 ;Tasten-Interrupt?
rjmp wt_tas_end ;dann die Warteschleife verlassen
cpi xh,31 ;maximal ca. 4 Sekunden auf Tastenereignis warten
brcs wt_tas_4sek
wt_tas_end:
out TCCR0B,nullreg ;Timertakt stoppen
out GIMSK,nullreg ;Pin-Change-Interrupt deaktivieren
in xl,TCNT0
ret
;----------------------------------------------------------------------
set_tim_2khz: ; *** Timer mit 2-kHz-Takt starten
ldi r16,(1<<CS01)+(1<<CS00) ;Timertakt = Systemtakt / 64 = 2 kHz
ldi r17,(1<<TOIE0) ;Timer-Overflow-Interrupt aktivieren
cpi phase,3 ;in Phase 3 sind zusätzliche Einstellungen erforderlich
brne set_tim_var
ldi r17,220 ;TCNT0-Vergleichswert für das LED-Ausschalten
out OCR0B,r17
ldi r17,(1<<TOIE0)+(1<<OCIE0B) ;zusätzlich Compare-Match-B-Interrupt
set_tim_var: ; *** Timer mit Parametern gemäß R16/R17 starten
; Aufgrund früherer Compare-Matches sind die entsprechenden Interrupt-
; Flags bereits gesetzt und müssen vor dem Int.-Aktiv. gelöscht werden
ldi xh,(1<<OCF0B)+(1<<OCF0A)+(1<<TOV0)
out TIFR0,xh
clr xh ;Überlauf-Reg. für den Timer, wird in Int.-Rout. inkrementiert
clr tim24bt ;dito, bei hoher Taktrate auch weiterer Überlauf
out TCNT0,nullreg ;Counter-Wert nullsetzen
out TIMSK0,r17 ;Timer-Interrupts aktivieren
out TCCR0B,r16 ;Timer mit gewünschtem Takt starten
ret
;----------------------------------------------------------------------
nxt_wuewert: ; *** Nächster Würfelwertindex (-1, mod 6)
dec wuewert ;nächster Würfelwertindex für die nächste Runde
brpl get_muster
ldi wuewert,5 ;nur Werte 0 bis 5, bei -1 Rücksetzen auf 5
get_muster: ; *** LED-Muster für den Würfelwertindex => ledmust
ldi_hl z,led_kombi*2 ;Basisadresse der Würfelwerte im Flash-Speicher
add zl,wuewert ;8bit-Addition genügt, da kleine Adresse
lpm ledmust,z ;LED-Kombination für den Würfelwert
ret
;----------------------------------------------------------------------
zufallszahl: ; *** Pseudo-Zufallszahl erzeugen (per LFSR mit 23 Bits)
; Input: XL = Anzahl n der zu erzeugenden Bits (1 ... 16)
; Output: XH:XL = Zufallszahl (in den unteren n Bits)
loop zuf_lp ;n Shift-Operationen mit Rückkopplung
mov xh,lfsr1
lsl xh ;bit 13 des LFSR steht nun in bit 6 von xh
eor xh,lfsr2 ;bit 22 und 13 des LFSR sollen verknüpft werden
lsl xh ;jetzt in bit 7
lsl xh ;jetzt im Carry-Flag
rol lfsr0 ;gesamtes LFSR links-shiften und neues Bit einschieben
rol lfsr1
rol lfsr2
next_down xl,zuf_lp ;n "neue bits" stehen bereit in LFSR
movw x,lfsr0
ret
;----------------------------------------------------------------------
xmod6: ; *** x := x mod 6; wuewert := xl
; nicht die schnellste, aber eine kurz zu formulierende Methode
xm6_xh: ;Berechnung xh := xh mod 6 - 6
subi xh,6
brcc xm6_xh
xm6_ueb_korr: ;Modulo-6-konforme Überlaufkorrektur
subi xl,4 ;256 - 4 = 252 ist durch 6 teilbar
brcc xm6_uebk_2
subi xl,-12 ;Ergebnis darf nicht negativ sein
xm6_uebk_2:
inc xh ;xh wird auf null gebracht
brne xm6_ueb_korr
xm6_xl: ;nun noch xl := xl mod 6
subi xl,6
brcc xm6_xl
subi xl,-6 ;Ergebnis liegt in [0;5]
mov wuewert,xl
ret
;----------------------------------------------------------------------
; ************************ Interrupt-Routinen ************************

; Um Zeit und Programmspeicherplatz zu sparen, wird das Statusregister
; nicht auf dem Stack zwischengespeichert, sondern in intreg (= R14).
; Dieses Register darf daher nur innerhalb der Interrupt-Routinen
; verwendet werden.

i_t0ov: ; *** Timer/Counter Overflow
; Bei Timertakt = 2 kHz (während des Würfelns) tritt dieser Interrupt
; etwa 8mal pro Sekunde auf und wird zu Darstellungszwecken gemäß
; Spielphase genutzt. Beim Aufglimmen des gewürfelten Wertes in Phase 1
; beträgt der Timertakt 128 kHz, und der Überlauf tritt 500mal / Sek.
; auf. Dann sind jeweils die LEDs auszuschalten. Register XH nimmt den
; Timer-Überlauf auf, so dass XH:TCNT0 einen 16bit-Zähler ergibt.
in intreg,sreg ;Statusregister merken
cpi phase,2
brcs iov_ende ;in Phase 0 oder 1 nichts weiter tun
push r16 ;diverse Register werden temporär benötigt
movw int_lwr,z
rcall get_muster ;LED-Kombination für den Würfelwert => ledmust
cpi phase,3
brcc iov_phm3 ;Phasen ab 3
iov_ph2: ;Phase 2, Blinken der zentralen LED
mov ledmust,einsreg ;alle LEDs aus
ldi r16,0b10001
sbrc xh,2
mov ledmust,r16 ;zentrale LED soll eingeschaltet werden
rjmp iov_outled
iov_phm3: ;Phasen ab 3
brne iov_phm4 ;Phasen ab 4
iov_ph3: ;Phase 3, Würfelwerte schnell durchlaufen lassen
rcall nxt_wuewert ;nächster Würfelwertindex
rjmp iov_outled
iov_phm4: ;Phasen ab 4
;iov_ph4: ;Phase 4; Würfel ausrollen lassen
; out PORTB,r16 ;momentanen Würfelwert anzeigen
dec ausr_ct ;zwei Zähler regeln das richtige Timing (ausrollen)
brne iov_outled; iov_pop ;diesmal keine Änderung
inc ausr_ln ;langsamer werden
mov ausr_ct,ausr_ln
rcall nxt_wuewert ;nächster Würfelwertindex
iov_outled:
out PORTB,ledmust ;Würfelwert/Effekt anzeigen
iov_pop:
movw z,int_lwr ;vorige Registerwerte wiederherstellen
pop r16
iov_ende:
add xh,einsreg ;so wird insgesamt ein 16bit-Zähler realisiert
adc tim24bt,nullreg ;bzw. 24bit (nur bei max. Timer-Taktrate)
iov_ret:
out sreg,intreg ;Statusregister wiederherstellen
reti
;----------------------------------------------------------------------
i_t0cmb: ; *** TIM0_COMPB Timer/Counter Compare Match B
; kurzzeitiges Ausschalten aller LESs in Phase 3, zwischen der
; Anzeige verschiedener Würfelwerte
out PORTB,einsreg ;alle LEDs aus
reti
;----------------------------------------------------------------------

i_pcint0: ; *** Tastenereignis
in intreg,sreg
sbr flags,(1<<7)+(1<<6) ;merken, dass Tastenereignis stattfand
sbic PINB,0
cbr flags,(1<<6) ;bedeutet, dass Taste losgelassen wurde
out GIMSK,nullreg ;keine externen Interrupts mehr annehmen
out sreg,intreg
reti
; ******************************* ENDE *******************************