UHR120_4.ASM

;************ DCF77 Uhr mit LCD Anzeige auf HD44???? Basis ******************

;*

;* - Ersteller: U.Hempel   eMail: heausc@aol.com

;* - frei für alle, die es nutzen wollen

;* - keine Garantie auf Fehler 

;* - erstellt: 2/2002 

;*

;* - Kontroller AT90S1200 mit 4 MHz Quarz

;* - 293 Worte

;* - Teiler (125(Uhr_ms)x125(tov0)x255(MCUCR)=4MHz->1s

;* - Quarzanpassung mit 125 +/- bei tov0 setzen

;* - tov0 erzeugt aller 8 ms einen Interrupt(wird auch für LCD_init gebraucht)

;* -

;* - mit interner Uhrzeit (Uhr_...)

;* -

;* - mit doppelter Patitätsprüfung!!!!

;* -

;* - mit Quersumme über alle DCF-Zahlen (Min_einer bis Jahr_zehner)

;* - 

;* - LCD 4Bit Modus

;* - LCD-Modul 2 x 16 Zeichen oben Zeit, unten Tag + Datum

;* - LCD-DB4-7 an PortB4-B7

;* -

;* - Port B0-B3 nur als Eingänge benutzen, die Ausgänge ändert lcdtmp !!!!!

;* - R/W an GND (nur schreiben)

;* - E = Takt an Port D0

;* - RS an Port D1

;* - LCD-Adresse 1.Zeile = $80 - $8f

;* - LCD-Adresse 2.Zeile = $c0 - $cf

;* - Tag->EEPr ab Adr. $02

;* - w_tag hat normal ein lsl,wegen EEPr Adr.2(x2) weggelassen

;*

;* - Werte für EEProm ab Adr. $00

;* - $0F,$0F,$1d,$3f,$14,$39,$1d,$39,$14,$3f,$16,$42,$23,$31,$23,$3f (+$30)

;**** ? * ? * M   o * D   i * M   i * D   o * F   r * S   a * S   o ******

;*

;* - Pd0 = Ausgang: E (Takt LCD)

;* - Pd1 = Ausgang: RS (Register Set LCD)

;* - Pd2 = Eingang: INT0 auf LH-Flanke von DCF-Modul

;* - 1.Zeile 2.+3.Zeichen >< für ok , <> für Fehler 

;* - Fehlersetzen mit:

;* - Nullimp wenn  sek. nicht 59 (DCF fehlt)

;* - falsche Parität 3x getestet

;* - Quersumme neue Min.<> Quersumme +1 alte Min (Fehler aller 10 Min,9->0)

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

.include "1200def.inc"

;***** globale Register Variablen *******************************************

;*** Rr-Register festlegen

.def  h_z  =r0    ;Stunden Zehner(0-2)

.def  h_e  =r1    ;Stunden Einer (0-9)

.def  min_z  =r2    ;Minuten Zehner(0-5)

.def  min_e  =r3    ;Minuten Einer (0-9)

.def  k_tag_e  =r4    ;Datumstag Einer(0-9)

.def  k_tag_z  =r5    ;Datumstag Zehner(0-3)

.def   w_tag  =r6    ;Wochentag Mo(1)-So(7)

.def  mon_e  =r7    ;Monat Einer  (0-9)

.def  mon_z  =r8    ;Monat Zehner  (0-2)

.def  jahr_e  =r9    ;Jahr Einer  (0-9)

.def  jahr_z  =r10    ;Jahr Zehner  (0-9)

.def  asci  =r11    ;zum ASCI erzeugen ($30)

.def  test_Q  =r12    ;alle DCF-Werte+,+1,-neue DCF-Werte=<0>=error

;*** Rd-Register festlegen

.def  temp  =r16    ;allgem. tempor.-Reg.

.def  sek  =r17    ;DCF-Sekunden 1-59

.def  testhl  =r18    ;test ob T<150ms oder >180ms;>1500ms=sek00

.def  set  =r19    ;Reg.zum setzen (übernimmt H/L-Bit als $8/$0)

.def  bits  =r20    ;Reg.zum Zusammenbauen des Zahlenwertes

.def  lcdtmp  =r21     ;

.def  takt  =r22    ;zum erzeugen des LCD-Takt mit TOV0

.def  error  =r23    ;Fehlermerker

.def  par  =r24    ;Paritätsreg.für H-Bits(exor)

.def  isr_tmp  =r25    ;Interrupt- Stack(S-Reg.)

.def  uhr_ms  =r26    ;int.Uhr ms, 125 x TOV0 = 1 sek

.def  uhr_s  =r27    ;int.Uhr sek(60)

.def  uhr_me  =r28    ;int.Uhr Min Einer

.def  uhr_mz  =r29    ;int.Uhr Min Zehner

.def  uhr_he  =r30    ;int.Uhr Stunden Einer

.def  uhr_hz  =r31    ;int.Uhr Stunden Zehner

;***** EEPromdaten für Wochentage *******************************************

.eseg

.org  0x00

.db  $0F,$0F,$1d,$3f,$14,$39,$1d,$39,$14,$3f,$16,$42,$23,$31,$23,$3f

;******* ? * ? * M   o * D   i * M   i * D   o * F   r * S   a * S   o ******

;***** Interrupt Vectoren ***************************************************

.cseg

.org   0x00    

  rjmp  RESET    ;Programmbeginn bei Reset 

  rjmp  impuls    ;EXT-IRQ (Pd2=LH)Impulsbeginn DCF77

  rjmp  tov    ;T0 ovf

  rjmp  RESET    ;AN-Comp

lcd_on:  out  portb,lcdtmp  ;

  cbi  portd,0    ;E = 0 = Daten übernehmen(LCD-Hig-Nibbel)

T0:  in  temp,TIFR  ;weiter erst wenn TOV0 = 1

  tst  temp

  breq  T0    ;sonst zurück->T0

  sbi  portd,0    ;E = 1

  out  tifr,temp  ;TOV0 löschen

  swap  lcdtmp    ;Nibbel tauschen

lcd_3:  out  portb,lcdtmp  ;unteres Nibbel ausgeben

  cbi  portd,0    ;E = 0 = Daten übernehmen(LCD-low-Nibbel)

T1:  in  temp,TIFR  ;weiter erst wenn TOV0 = 1

  tst  temp

  breq  T1    ;sonst zurück->T1

  sbi  portd,0    ;E = 1

  out  tifr,temp  ;TOV0 löschen

  ret  

RESET:  ldi  temp,$4    ;Vorteiler = 4MHz/256=64µs

  out  TCCR0,temp  ;*125(TMR0)=8ms je TOV0 (16,4ms bei lcd_on)

  clr  bits

  ldi  uhr_ms,125

  ldi  uhr_s,60  ;60 sek

  clr  uhr_me    ;int. Uhr alles auf null stellen

  clr  uhr_mz

  clr  uhr_he

  clr  uhr_hz

  ldi  temp,$30  ;zum ASCI erzeugen

  mov  asci,temp  ;umladen

  out  portb,bits  ;an Portb alles mit L vorbelegen

  ldi  temp,$f0

  out  ddrb,temp  ;Port b4-b7 = Ausgang

  ldi  error,1    ;

  out  portd,error  ;PD0=1(E)+PD1=0(RS)vorbelegen

  inc  error    ;Fehler setzen

  out  TIFR,error  ;TOV0 sicherheitshalber löschen

  ldi  temp,0b00000011  ;temp=$3

  out  ddrd,temp  ;PD0+PD1=Ausgang

Pause:  in  temp,TIFR  ;weiter erst wenn TOV0 = 1

  tst  temp

  breq  Pause    ;sonst zurück->Pause (LCD-Einschaltpause)

LCDinit:ldi   lcdtmp,$28  ;LCDinit(DB4=0;DB5=1)

  rcall  lcd_3    ;1.mal LCD_init (nur 1 Nibbel)

  rcall  lcd_3    ;DB4= 0 = Datenlänge = 4 Bit(nur Hig-Nibbel)

  rcall  lcd_on    ;jetzt komplett

  ldi  lcdtmp,$0c  ;Displ an.+ Kursor aus (mit Kurs.=$0e)

  rcall  lcd_on

  ldi  lcdtmp,1  ;1 = Anz.auf 1.Zeichen + Displ.= cls

  rcall  lcd_on

  ldi  temp,$3

  OUT  TIMSK,temp  ;Timer Int.on

  OUT  MCUCR,temp  ;INT0 mit steigende Flanke

  ldi  temp,$40

  out  gimsk,temp  ;INT0(PB2) ein

  sei      ;INT glob.ein

;******* Hauptprogramm **************************

HP:  ldi  lcdtmp,$82  ;1.Zeile 3. Zeichen

  rcall   Fu_set    ;Funktion setzen

  tst  error

  breq  sig_ok    ;wenn error=0 ->sig_ok

  ldi  lcdtmp,$0c  ;$0c+$30= (<)

  rcall  Z_set

  ldi  lcdtmp,$0e  ;$0e+$30= (>)

  rcall  Z_set

  rjmp  fe1    ;kein Datum ausgeben,nur int.Uhr

sig_ok:  ldi  lcdtmp,$0e  ;$0e+$30= (>)

  rcall  Z_set

  ldi  lcdtmp,$0c  ;$0c+$30= (<)

  rcall  Z_set

  ldi  lcdtmp,$c2  ;2. Zeile 3.Zeichen

  rcall  Fu_set

  mov  lcdtmp,w_tag

  rcall  eelese    ;EEProm lesen (Wochentag als Zeichen Mo-So)

  rcall  Z_set

  mov  lcdtmp,w_tag  ;Adresse nochmal hohlen

  inc  lcdtmp    ;+1 (2.Buchstabe)

  rcall  eelese

  rcall  Z_set

  ldi  lcdtmp,$c5  ;2. Zeile 6.Zeichen

  rcall  Fu_set

  mov  lcdtmp,k_tag_z

  rcall  Z_set

  mov  lcdtmp,k_tag_e

  rcall  Z_set

  ldi  lcdtmp,$fe  ;ASCI Punkt($2e)

  rcall  Z_set

  mov  lcdtmp,mon_z

  rcall  Z_set

  mov  lcdtmp,mon_e

  rcall  Z_set

  ldi  lcdtmp,$fe  ;ASCI Punkt (+$30=$2e)

  rcall  Z_set

  mov  lcdtmp,jahr_z

  rcall  Z_set

  mov  lcdtmp,jahr_e

  rcall  Z_set

fe1:  ldi  lcdtmp,$86  ;1.Zeile 7. Zeichen

  rcall   Fu_set    ;Funktion setzen

  mov  lcdtmp,uhr_hz

  rcall  Z_set

  mov  lcdtmp,uhr_he

  rcall  Z_set

  ldi  lcdtmp,$0a  ;Doppelpunkt ($3a)

  rcall  Z_set

  mov  lcdtmp,uhr_mz  ;min_z

  rcall  Z_set

  mov  lcdtmp,uhr_me  ;min_e

  rcall  Z_set

  ldi  error,1    ;Fehler setzen (wird,wenn alles ok,bei syn=0)

neu:  brtc  neu    ;wenn T-Flag = 0 -> neu

  clt      ;sonst T-Flag = 0 (nur eine Ausgabe)

  rjmp  HP    ;und Zeiten ausgeben

;****** ein Zeichen oder eine Funktion setzen *******************************

Z_set:  sbi  portd,1    ;RS = 1

  add  lcdtmp,asci  ;ASCI erzeugen

Fu_set:  out  portb,lcdtmp

  inc  takt    ;mit TOV0 Takt erzeugen

  cbi  portd,0    ;E = 0 = Daten übernehmen(LCD)

t4:  tst  takt    ;takt noch 1? ->t4

  brne  t4

  sbi  portd,0    ;E = 1      

  swap  lcdtmp    ;Nibbel tauschen

  out  portb,lcdtmp  ;und Low-Nibbel ausgeben

  inc  takt    ;mit TOV0 Takt erzeugen

  cbi  portd,0    ;E = 0 = Daten übernehmen(LCD)

t5:  tst  takt    ;takt noch 1? ->t2

  brne  t5

  sbi  portd,0    ;E = 1

  cbi  portd,1    ;RS = 0

  ret

;****** EEProm lesen *******************************************************

eelese:  out  eear,lcdtmp  ;Wochentag(1-7)->EEPr. Adresse

  sbi  eecr,0    ;EEPr.lesen (eere=1)

le1:  sbic  eecr,0    ;warten bis eere = 0 (EEPr-Daten ok)

  rjmp  le1

  in  lcdtmp,eedr  ;Zeichen holen

  ret

;****** INT0 (DCF-Signal) bearbeiten ****************************************************

impuls:  in  isr_tmp,sreg  ;Flagreg.sichern

  cpi  testhl,114  ;912ms

  brcs  igno    ;wenn kleiner -> igno

  clr  testhl    ;Timerreg=0

  inc  sek    ;DCF-sek + 1

igno:  out  sreg,isr_tmp  ;Flag's zurückschreiben

  reti

;****** TOVO bearbeiten ****************************************************

;**** 1. -interne Uhr ************

tov:  in  isr_tmp,sreg  ;Flagreg.sichern  

  ldi  temp,$ff-122  ;Quarzanpassung hier in Schritten von 64µs

  out  TCNT0,temp  ;(122+1)125 Takte bis TOVO

  clr  takt    ;LCD-Takt

  dec  uhr_ms

  brne  uhr_e    ;wenn nicht 0 ->uhr_e

  ldi  uhr_ms,125  ;neu laden

  dec  uhr_s

  brne  uhr_e    ;wenn nicht 0 ->uhr_e

  ori  isr_tmp,$40  ;T-Flag für Ausgabe setzen

  ldi  uhr_s,60  ;60 sek

  inc  uhr_me    ;min + 1

  cpi  uhr_me,10  ;

  brcs  uhr_e    ;< 10

  clr  uhr_me    ;min einer = 0

  inc  uhr_mz    ;min zehner + 1

  cpi  uhr_mz,6  ;

  brcs  uhr_e    ;< 6

  clr  uhr_mz    ;min zehner = 0

  inc  uhr_he    ;h einer + 1

  cpi  uhr_he,4  ;>=(2)4 Stunden

  brne  te_10    ;<>!

  cpi  uhr_hz,2  ;Sundenzehner = 2 ?

  brcs  te_10

  clr  uhr_he

  clr  uhr_hz

  rjmp  uhr_e

te_10:  cpi  uhr_he,10

  brcs  uhr_e    ;<10!

  clr  uhr_he

  inc  uhr_hz    ;Stundenzehner + 1

;*** 2. -DCF auswerten ***************

uhr_e:  in  temp,pind  ;Port d->temp (aller 8ms)

  andi  temp,4    ;Pd2 ausfiltern

  inc  testhl    ;Timerreg. + 1

  cpi  testhl,18  ;=144ms ?

  breq  bit_hl    ;wenn = 144ms->bit_hl

  cpi  testhl,40  ;=320ms ?

  breq  bitset    ;wenn 320ms->bitset

  cpi  testhl,165  ;1320ms ?

  breq  syn    ;wenn 1320ms ->syn (nur wenn INT0 ausbleibt)

  rjmp  isrend    ;reti

bit_hl:  tst  temp    ;

  brne  bit_1    ;wenn temp(Pd2) nicht 0->bit_1

  mov  set,temp  ;sonst set wird 0

  rjmp  isrend    ;reti

bit_1:  ldi  set,$8    ;sonst wird set=8(Bit3)

  eor  par,set    ;aus par=0 wird par=1 und par=1 wird par=0

  rjmp  isrend    ;reti;in bitset bei sek 29 muß par=0 sein

syn:  add  sek,par    ;3.Paritätstest

  add  sek,temp  ;wehe wenn bei syn ein Sign.an Pb2

  cpi  sek,59    ;DCF-Sek bei syn = 59?

  brne  Fehl_1    ;wenn nein Fehl_1

  mov  temp,min_e  ;Minuten einer->temp

  add  temp,min_z  ;+ Minuten Zehner

  add  temp,h_e  ;+ Stunden Einer

  add  temp,h_z  ;+ Stunden Zehner

  add  temp,w_tag  ;+ Wochentag(2-14)

  add  temp,k_tag_z  ;+ Datumstag Zehner(0-3)

  add  temp,k_tag_e  ;+ Datumstag Einer(0-9)

  add  temp,mon_e  ;+ Monat Einer  (0-9)

  add  temp,mon_z  ;+ Monat Zehner  (0-2)

  add  temp,jahr_e  ;+ Jahr Einer  (0-9)

  add  temp,jahr_z  ;+ Jahr Zehner  (0-9)

  cp  temp,test_Q  ;mit altem Wert vergleichen

  brne  Fehl_1    ;wenn nicht gleich -> Fehl_1

;****** DCF Sign.ok! *********************

  mov  jahr_z,bits  ;Jahr Zehner  (0-9) abspeichern

  clr  error    ;wird nach jeder Ausgabe gesetzt

  ldi  uhr_s,60  ;int.sek synchronisieren

  mov  uhr_hz,h_z  ;DCF-Zeit nach int.Uhr

  mov  uhr_he,h_e

  mov  uhr_mz,min_z

  mov  uhr_me,min_e  ;wenn kein Fehler erkannt

  ori  isr_tmp,$40  ;T-Flag für Ausgabe setzen

  rjmp  Fehl_2

Fehl_1:  clr  par    ;Parität reset bei Fehler

Fehl_2:  clr  sek    ;sek = 0 (59.Sekunde oder Fehler)

  inc  temp    ;+1 Min.für test_Q (aller 10 Min.= Fehler!)

  mov  test_Q,temp  ;und abspeichern

  rjmp  isrend    ;reti  

;**** Achtung Sek. 60 bringt 1. Zählimpuls deshalb alle Takte +1 ***********

bitset:  cpi  sek,22

  brcs  isrend    ;wenn >,->isrend

  cpi  sek,26

  brcs  lade1    ;wenn < 25-> lade1 (Min.Einer (0-9))

  breq  MZ    ;1.Min.Zehner und Min Einer sichern

  cpi  sek,29

  brcs  lade1    ;wenn < 29 ->lade1 (Min.Zehner (0-5))

  breq  parit    ;wenn =29 ->Paritätstest

  cpi  sek,30

  breq  STE    ;1.Stunden Einer und Min Zehner sichern

  cpi  sek,34

  brcs  lade1    ;wenn < 34 ->lade1 (Stunden Einer (0-9))

  breq  STZ    ;1.Stunden Zehner und Stunden Einer sichern

  cpi  sek,36

  brcs  lade1    ;wenn <36 -> lade1 (Stunden Zehner (0-2))

  breq  parit    ;2.Paritätstest

Datum:  cpi  sek,37

  breq  KTE    ;1.Kalendertag Einer(Stunden Zehner sichern)

  cpi  sek,41

  brcs  lade1    ;wenn <41->lade1 (Kalendertag Einer (0-9))

  breq  KTZ    ;1.Kalendertag Zehner(Kal.tag Einer sichern)

  cpi  sek,43

  brcs  lade1    ;wenn < 43->lade1 (Kalendertag Zehner (0-2))

  breq  WT    ;1.Wochentag und Kal.tag Zehner sichern

  cpi  sek,46

  brcs  lade1    ;wenn < 46 ->lade1 (Wochentag 1-7)

  breq  MOE    ;1.Monat Einer und Wochentag sichern

  cpi  sek,50

  brcs  lade1    ;wenn < 50->lade1 (Monat Einer (0-9))

  breq  MOZ    ;Monat Zehner (0,1)und Monat Einer sichern

  cpi  sek,55

  brcs  lade1    ;wenn < 55->lade1 (Jahr Einer (0-9))

  breq  JZ    ;1.Jahr Zehner und Jahr Einer sichern

  cpi  sek,59

  brcs  lade1    ;wenn < 59 ->lade1 (Jahr Zehner (0-9))

  rjmp  isrend    ;ende Abfrage

STZ:  mov  h_e,bits

lade1:  lsr  bits    ;Ladeprogr.für restliche bits(1xrechts)

  or  bits,set  ;8 oder 0 einfügen

isrend:  out  sreg,isr_tmp  ;Flag's zurückschreiben

  reti

parit:  tst  par

  breq  par_1    ;wenn Parität = 0 ist alles ok.

  ldi  sek,60    ;sonst Fehler erzeugen(DCF-sek <>59)

par_1:  rjmp  isrend    ;reti

MZ:  mov  min_e,bits

  rjmp  lade1  

STE:  lsr  bits    ;1x Stellenkorrektur

  mov  min_z,bits

  rjmp  lade1

KTE:  lsr  bits

  lsr  bits    ;2x Stellenkorrektur

  mov  h_z,bits  ;Stundenzehner

  rjmp  lade1

KTZ:  mov  k_tag_e,bits

  rjmp  lade1

WT:  lsr  bits

  lsr  bits    ;2x Stellenkorrektur  

  mov  k_tag_z,bits

  clr  bits    ;bits müssen null sein weil 1xlsr weggelassen

  rjmp  lade1

MOE:  ;lsr  bits    ;1x Stellenkorrektur (nicht,weil EEAdr*2)

  mov  w_tag,bits  ;Wochentag Mo(1)-So(7)bzw.(2-F)

  rjmp  lade1

MOZ:  mov  mon_e,bits  ;Monat Einer  (0-9)

  clr  bits

  sbrc  set,3    ;wenn Bit3 in set = 0 überspringe

  inc  bits    ;bits=1

  mov  mon_z,bits  ;Monat Zehner  (0-1)

  rjmp  isrend    ;reti

JZ:  mov  jahr_e,bits  ;Jahr Einer  (0-9)

  rjmp  lade1

;******* decodieren Ende *************************************************