fptest10.asm

;****************************************************************************************
;*                          Testprogramm variable PWM                                   *
;*                        Controller: 8515   Clock  = 4 MHz                             *
;*    PWM Variabel,Frequenz variabel                                                    *
;*    Rechenroutine zur Bestimmumg des Puls / Pausenverhältnisses aus                   *
;*    gewählter Frequenz und Ansteuerung Port B über Drehimpulsgeber.                   *
;*    do: Grenzwertberchnung                                                            *
;****************************************************************************************
.include "C:\vmlab\include\4414def.inc"
.def  stat     =  r13      ;Statusregister Hauptprogramm
.def  addlo    =  r16      ;Hilfsregister addition Timersektion
.def  fahrt    =  r17      ;Register fuer Fahrtstufe
.def  workh    =  r20      ;Speicherregister Hauptprogramm
.def  workl    =  r21      ;Speicherregister Timersektion
.def  temp1    =  r18      ;mehrzweck
.def  temp2    =  r19      ;mehrzweck
.def  temp3    =  r24      ;mehrzweck
.def  temp4    =  r25      ;mehrzweck
.def  lpause   =  r26      ;lowbyte pause
.def  hpause   =  r27      ;highbyte pause
.def  lpuls    =  r28      ;lowbyte impuls
.def  hpuls    =  r29      ;highbyte impuls
.def  drem16ul =  r14      ;remainder lowbyte
.def  drem16uh =  r15      ;remainder highbyte
.def  dres16ul =  r16      ;Ergebniss division lowbyte
.def  dres16uh =  r17      ;Ergebniss division highbyte
.def  dd16ul   =  r16      ;divident lowbyte
.def  dd16uh   =  r17      ;divident highbyte
.def  dv16ul   =  r18      ;divisor lowbyte
.def  dv16uh   =  r19      ;divisor highbyte
.def  mc16ul   =  r16      ;multiplicand lowbyte
.def  mc16uh   =  r17      ;multiplicand highbyte
.def  mp16ul   =  r18      ;multiplier lowbyte
.def  mp16uh   =  r19      ;multiplier highbyte
.def  m16u0    =  r18      ;Ergebniss byte 0 (LSB)
.def  m16u1    =  r19      ;Ergebniss byte 1
.def  m16u2    =  r20      ;Ergebniss byte 2
.def  m16u3    =  r21      ;Ergebniss byte 3 (MSB)
.def  cnt      =  r22      ;Counter für Rechenroutinen
.equ  startwert=  23       ;PWM auf 95% Pausenzeit festlegen
.equ  frequenz =  6240     ;Dezimalwert für Frequenz
.equ  step    =  1
rjmp           initial     ;Controler initialisieren
reti                       ;externer Interrupt0, noch frei
reti                       ;capture Interrupt, noch frei
rjmp           timer1compa ;Timer1 Compare A  Interrupt
rjmp        t1_ovfl    ;Counter 0 Überlauf, Erkennung Drehimpulsgeber
initial:
ldi   workh,high(ramend)
out   sph,workh
ldi   workh,low(ramend)
out   spl,workh
ldi   workh,$20            ;PD5 ist Ausgang PWM Signal, Rest ist Eingang
out   ddrd,workh
ldi   workh,$df
out   portd,workh          ;Eingänge Port D Pullups aktiviert
clr   workh
out   ddrb,workh           ;port b ist eingang
ser   workh
out   portb,workh          ;Pullups Port b aktiviert
out  ddrc,workh        ;Port C ist Ausgang
ldi  workh,$42
out  timsk,workh        ;Timer / Counter 0 Interruptfreigabe
ldi  workh,$fe
out  tcnt0,workh        ;Timerzählregister auf 255 setzen
ldi  workh,$07
out  tccr0,workh        ;Timer 0 = Countermode, steigende Flanke an PB 0
;---------------------------------------------------------------------------------
;---------------------------------------------------------------------------------
;----------- 1.Berechnung prozentualer Anteil P/P - Grundwert
;1.division, Faktor errechnen und Ergebniss in r16 und r17
ldi   dd16ul,low(frequenz)
ldi   dd16uh,high(frequenz)
ldi   dv16ul,low(24)
ldi   dv16uh,high(24)
rcall calc1
sts   $0065,dres16ul
sts   $0064,dres16uh
;2. Multiplikation, Ergebniss Pausenzeit in m16u0 - m16u3
ldi   mp16ul,low(startwert)     ;Multiplikator lowbyte
ldi   mp16uh,high(startwert)    ;Multiplikator highbyte
rcall calc2
;3. Pulszeit errechnen, PWM starten
mov   lpause,m16u0         ;lowbyte Pause nach lpause schieben
mov   hpause,m16u1         ;highbyte Pause nach hpause schieben
rcall calc3
;4. unteren Grenzwert berechnen
ldi  mp16ul,low(1)
ldi  mp16uh,high(1)
rcall  calc2
sts  $0066,m16u1
sts  $0067,m16u0
rcall  calc3
sts  $0068,hpuls
sts  $0069,lpuls
;5. oberen Grenzwert berechnen
ldi  mp16ul,low(23)
ldi  mp16uh,high(23)
rcall  calc2
sts  $006a,m16u1
sts  $006b,m16u0
rcall  calc3
sts  $006c,hpuls
sts  $006d,lpuls
ldi   workh,$01
sts   $0070,workh        ;speicherstelle Fahrtstufe
rcall startpwm             ;Grundwerte Pause setzen
lds   hpause,$60           ;aktueller wert Pause (highbyte)
lds   lpause,$61           ;aktueller wert Pause (lowbyte)
lds   hpuls,$62            ;aktueller wert Impuls (highbyte)
lds   lpuls,$63            ;aktueller wert Impuls (lowbyte)
lds  temp1,$0070
out  portc,temp1
rjmp  loop
;---------------------------------------------------------------------------------
;I                           PWM Interrupt Routine                               I
;---------------------------------------------------------------------------------
startpwm:
sts   $0060,hpause
sts   $0061,lpause
sts   $0062,hpuls
sts   $0063,lpuls
out   ocr1ah,hpause        ;speichern high byte PAUSE (toff) ocr1a
out   ocr1al,lpause        ;speichern low byte PAUSE (toff) ocr1a
ldi   workh,$c0
out   tccr1a,workh         ;nach 1. Comp.A Interrupt ->1
ldi   workh,$02            ;T/C1 clock = Systemclock/8
out   tccr1b,workh         ;Start T/C1
ldi   workh,$42
out   timsk,workh          ;set Comp. A Interrupt (+ Timer 0 Interrupt)
;------------------------------ Interruptroutine PWM ----------------------------
timer1compa:
in    stat,sreg            ;retten sreg
;clr   workh
;out   gimsk,workh          ;int1 sperren
com   lpuls
com   hpuls                ;1er Komplement bilden hpuls
com   lpause               ;lpause invertieren
com   hpause               ;hpause negieren
in    workl,tccr1a         ;T/C1 control register A
sbrs  workl,com1a0         ;Befehl überspringen wenn  com1a0 =1
rjmp  tc1                  ;springen wenn com1a0 = 0
cbr   workl,1<<com1a0      ;next interrupt oc1a -> 0
out   tccr1a,workl         ;speichern  tccr1a
in    addlo,ocr1al         ;holen low byte ocr1a
sub   addlo,lpuls          ;und addieren low byte ton
in    workl,ocr1ah         ;high byte ocr1a
sbc   workl,hpuls          ;addieren high byte ton
rjmp  intende
sbr   workl,1<<com1a0      ;next interrupt oc1a -> 1
out   tccr1a,workl         ;neuen Wert zurückspeichern
in    addlo,ocr1al         ;hole low byte ocr1a
sub   addlo,lpause         ;addiere low byte toff
in    workl,ocr1ah         ;nächstes byte ocr1
sbc   workl,hpause         ;und addieren high byte toff
intende:
out   ocr1ah,workl         ;speichern neues high byte ocr1a
out   ocr1al,addlo         ;speichern neues low byte ocr1a
out   sreg,stat            ;SREG wiederherstellen
; Ende PWM Routine
;---------------------------------------------------------------------------------
;I                        Drehgeber-Interruptroutine                             I
;---------------------------------------------------------------------------------
t1_ovfl:
in    temp3,sreg        ;SREG sichern
push  workh
lds  fahrt,$0070          ;aktuellen Wert Fahrtsufe holen
in    workh,pinb        ;Bitmuster Eingang Port B holen
sbrs  workh,1          ;Bit an PB1 = H ?
rjmp  down            ;wenn ja, dann nach "down"
ldi  workh,low(step)    ;Wert für Schrittweite holen
add  fahrt,workh        ;Schrittweite addieren und in "Fahrt" speichern
rcall  ogrenzwert        ;Zur Routine "oberer Grenzwert erreicht?"
rjmp  end_t0int
subi  fahrt,step        ;Wert für Fahrtstufe verringern
rcall  ugrenzwert           ;Zur Routine "unterer Grenzwert erreicht?"
sts  $0070,fahrt        ;Wert für Fahrtstufe in SRAM sichern
rjmp  end_t0int
ogrenzwert:
ldi  workh,$17        ;maxwert 24 für oberen Grenzwert
cp    fahrt,workh        ;Fahrtstufe mit Grenzwert vergleichen
brsh  setmax          ;wenn gleich oder größer, maxwert festlegen
ret                ;sonst zurück
setmax:
ldi  fahrt,$17        ;maxwert ist 230
ugrenzwert:
ldi  workh,$00        ;unterer Grenzwert = 0
cp    fahrt,workh        ;Fahrtstufe mit Grenzwert vergleichen
breq  setmin          ;wenn = erreicht, Wert festlegen
setmin:
ldi  fahrt,$01        ;minwert Fahrtstufe ist 1
end_t0int:
sts  $0070,fahrt        ;neuen Wert für Fahrtstufe in SRAM sichern
rcall  fahrtstufe
ldi  workh,$ff        
out  tcnt0,workh        ;Counter-Register auf 255 setzen
pop  workh
out  sreg,temp3
fahrtstufe:
ldi  temp1,$02
out  timsk,temp1
lds  mc16ul,$65        ;Konstante aus "calc1" lowbyte aus SRAM holen
lds  mc16uh,$64        ;Konstante aus "calc1" highbyte aus SRAM holen
lds  mp16ul,$70        ;Wert für Fahrtstufe lowbyteaus SRAM holen
ldi  mp16uh,$00        ;highbyte Fahrtstufe auf 0 setzen
rcall  calc2            ;Multiplikation aufrufen
sts  $0063,m16u0        ;Ergebniss lowbyte Pulsdauer in SRAM sichern
sts  $0062,m16u1        ;Ergebniss highbyte Pulsdauer in SRAM sichern
mov  lpuls,m16u0        ;lowbyte Pulsdauer nach lpuls schieben
mov  hpuls,m16u1        ;highbyte Pulsdauer nach hpuls schieben
rcall  calc4            ;Subtraktion Frequenz-Pulsdauer aufrufen
sts  $0060,hpause      ;Ergebniss highbyte Pausendauer in SRAM sichern
sts  $0061,lpause      ;Ergebniss lowbyte Pausendauer in SRAM sichern
ldi  temp1,$42
out  timsk,temp1
ret    
;---------------------------------------------------------------------------------
;---------------------------------------------------------------------------------
;--------------- 16 / 16bit Division
div16u:
clr   drem16ul             ;Hilfsregister lowbyte lschen
sub   drem16uh,drem16uh    ;Hilfsregister highbyte und carry lschen
ldi   cnt,17               ;Schleifenzhler initialisieren
d16u_1:
rol   dd16ul               ;lowbyte dividend links schieben
rol   dd16uh               ;highbyte dividend links schieben
dec   cnt                  ;Schleifenzhler um 1 runterzhlen
brne  d16u_2
d16u_2:
rol   drem16ul             ;lowbyte dividend im Hilfsregister schieben
rol   drem16uh             ;highbyte dividend im Hilfsregister schieben
sub   drem16ul,dv16ul      ;lowbyte divisor von temp1 abziehen
sbc   drem16uh,dv16uh      ;highbyte divisor von temp2 abziehen
brcc  d16u_3               ;wenn Ergebniss negativ, springen nach "bertrag"
add   drem16ul,dv16ul
adc   drem16uh,dv16uh
rjmp  d16u_1
d16u_3:
rjmp  d16u_1
;--------------- 16 * 16bit Multiplikation
clr   m16u3
clr   m16u2
ldi   cnt,16
lsr   mp16uh
ror   mp16ul
m16u_1:
brcc  noadd8
add   m16u2,mc16ul
adc   m16u3,mc16uh
noadd8:
ror   m16u3
ror   m16u2
ror   m16u1
ror   m16u0
dec   cnt
brne  m16u_1
;--------------- 16 - 16bit Subtraktion
ldi   workh,low(frequenz)  ;lowbyte von Sollfrequenz holen
sub   workh,lpause         ;lowbyte von Pausenzeit abziehen
mov   lpuls,workh          ;Wert nach lowbyte Impuls schieben
ldi   workh,high(frequenz) ;highbyte von Sollfrequenz holen
sbc   workh,hpause         ;Pausenzeit mit Uebertrag subtrahieren
mov   hpuls,workh          ;Wert nach highbyte Impuls schieben
ldi   workh,high(frequenz)  ;lowbyte von Sollfrequenz holen
sub   workh,hpuls         ;lowbyte von Pausenzeit abziehen
mov   hpause,workh          ;Wert nach lowbyte Impuls schieben
ldi   workh,low(frequenz) ;highbyte von Sollfrequenz holen
sbc   workh,lpuls         ;Pausenzeit mit Uebertrag subtrahieren
mov   lpause,workh          ;Wert nach highbyte Impuls schieben
Kontakt/Impressum – Datenschutzerklärung – Nutzungsbedingungen – Werbung auf Mikrocontroller.net