Henrik, vielen Dank, da habe ich ja wieder was zum Ausprobieren!

Warum funktioniert eigentlich Albundys Lib nicht mit den internen Variablen der Softclock, also z.B. so:
Code:
copyright    = W.Krueger, geändert D. Ottensmeyer
comment      = DCF 77 Decoder
libversion   = 1.00
date         = 02.04.2006
statement    = ----------------------------------
statement    = muss alle 25ms ausgeführt werden !
statement    = ----------------------------------

[Dcf77]
Dcf77:
.equ DCF_Port = $10    ;$10 = Pind
.equ DCF_Pin = 3       ;3 = Pin 3

.equ Imp0min = 70      ;minimale Länge des Minutenimpulses
.equ Imp1min = 6       ;minimale Länge des "1" Impulses 
                       ;alles darunter wird als "0" Impuls gewertet
.def Temp1   = r16
.def Temp2   = r17
.def Temp3   = r18
.def _min    = r19
.def _hour   = r20
.def Status  = r21
              ;Bit0 = aktueller DCF Status
              ;Bit1 = vorheriger DCF Status
              ;Bit2 = Uhr synchronisieren
              ;Bit3 = 59 Impulse empfangen
              ;Bit4 = Parität OK
.def Impuls  = r22
.def Zaehler = r23
.def Buffer  = r24
.def Pari    = r25
;------------------------------------
 *lds Status,{Status}         ;Status laden
  rcall Softuhr               ;Softuhr bearbeiten
 *lds Impuls,{Impuls}         ;Variablen laden
 *lds Zaehler,{Zaehler}
 *lds Buffer,{Buffer}
 *lds Pari,{Pari}    
  in temp1,Dcf_Port           ;DCF Port lesen
  bst temp1,Dcf_Pin           ;Status holen
  bld Status,0                ;aktuellen Status speichern
  inc Zaehler                 ;Impulslänge erhöhen
  bst Status,0                ;akuellen Status prüfen
  brts Puls20                 ;Status Low -> weiter
  bst Status,1                ;vorherigen Status prüfen
  brtc Puls40                 ;vorheriger Status Low -> Ende
  ldi temp1,Imp0min           ;Minutenimpuls Minimalwert laden
  cp Zaehler,temp1            ;Impulslänge Minimalwert überschritten
  brcs Puls10                 ;nein -> weiter
 *sts {Pau},Zaehler           ;--------> Minutenimpulslänge speichern für Debug
  clr Buffer                  ;Empfangspuffer löschen
  clr Impuls                  ;Impulszähler löschen
  bst Status,4                ;Parität OK ?
  brtc Puls5                  ;Nein -> weiter
  bst Status,3                ;59 Impulse empfangen ?
  brtc Puls5                  ;Nein -> weiter
  set
  bld Status,2                ;Status Uhr synchronisieren setzen
Puls5:
  clt
  bld Status,3                ;Status 59 Impulse löschen
  bld Status,4                ;Status Parität OK löschen
Puls10:
  clr Zaehler                 ;Impulslänge löschen
  rjmp Puls40                 ;Ende
Puls20:
  bst Status,1                ;vorherigen Status prüfen
  brts Puls40                 ;vorheriger Status Low -> Ende
  ldi temp1,Imp1min           ;Minimalwert für "1" Impuls laden 
  cp Zaehler,temp1            ;Minimalwert unterschritten ?
  brcs Puls30                 ;ja -> weiter
 *sts {imp},Zaehler           ;--------> Impulslänge Height speichern für Debug
  cpi Impuls,28               ;beim Paritätsbit Min keine Negation
  breq Puls25
  cpi Impuls,35               ;beim Paritätsbit Std keine Negation
  breq Puls25
  ldi Temp1,1
  eor Pari,Temp1              ;Paritätsbit Negation
Puls25:
  sec                         ;Carry setzen ( "1" empfangen )
  ror Buffer                  ;Carry in Empfangspuffer
  inc Impuls                  ;Impulszähler erhöhen
  rcall Auswerten             ;Impulse auswerten
  rjmp Puls40                 ;Ende
Puls30:
 *sts {imp},Zaehler           ;--------> Impulslänge Low speichern für Debug
  clc                         ;Carry löschen ( "0" empfangen )
  ror Buffer                  ;Carry in Empfangspuffer
  inc Impuls                  ;Impulszähler erhöhen
  rcall Auswerten             ;Impulse auswerten
Puls40:
  bst Status,0                ;aktuellen Status holen
  bld Status,1                ;Status speichern
 *sts {Status},Status         ;Variablen wieder speichern
 *sts {Impuls},Impuls
 *sts {Zaehler},Zaehler
 *sts {Buffer},Buffer
 *sts {Pari},Pari    
  ret
;-------------------------------------------------------------------------------
Softuhr:
 *lds Temp1,{H_Sek}
 *lds Temp2,{_sec}
 *lds _min,{_min}       
 *lds _hour,{_hour} 
  bst Status,2                ;Status Uhr synchronisieren ?
  brtc Soft10                 ;nein -> weiter Softuhr
  clt
  bld Status,2                ;Status Synchron löschen ?
  clr Temp1                   ;Hundertstel löschen
  clr Temp2                   ;Sekunde löschen
 *lds Temp3,{T_Min}
  mov _min,Temp3              ;Minute auf empfangene Minute
 *lds Temp3,{T_Std}
  mov _hour,Temp3             ;Stunde auf empfangene Stunde
  rjmp Soft20                 ;empfangene Zeit übernehmem
Soft10:
  inc Temp1                   ;Hundertstel Sek erhöhen
  cpi Temp1,40                ;1000ms erreicht ?
  brne Soft20                 ;nein -> Ende
  clr Temp1                   ;Hundertstel Sek löschen
  inc Temp2                   ;Sekunde erhöhen
  cpi Temp2,60                ;60 Sekunden erreicht ?
  brne Soft20                 ;nein -> Ende
  clr Temp2                   ;Sekunde löschen
  inc _min                    ;Minute erhöhen
  cpi _min,60                 ;60 Minuten erreicht ?
  brne Soft20                 ;nein -> Ende
  clr _min                    ;Minute löschen
  inc _hour                   ;Stunde erhöhen
  cpi _hour,24                ;24 Stunden erreicht ?
  brne Soft20                 ;nein -> Ende
  clr _hour                   ;Stunde löschen
Soft20:
 *sts {H_Sek},Temp1           ;Basic Variablen mit empfangenen
 *sts {_sec},Temp2            ;Werten laden
 *sts {_min},_min
 *sts {_hour},_hour
  ret                         
;-------------------------------------------------------------------------------
Auswerten:
  cpi Impuls, 21              ;21. Impuls
  brne Aus10                  ;nein -> weiter
  clr Buffer
  clr Pari
Aus10:
  cpi Impuls, 28             ;28. Impuls
  brne Aus15                 ;nein -> weiter
  lsr Buffer                 ;Buffer 1x schieben, da Minute nur 7 Bit
  rcall Bcd2dez              ;in Dezimal wandeln
 *sts {T_Min},Buffer         ;Temp Minute schreiben
  clr Buffer
Aus15:
  cpi Impuls, 29             ;Minuten Parität
  brne Aus20
  clr Temp3
  bst Buffer,7               ;Paritätsbit selektieren
  bld Temp3,0                ;Paritätsbit in Temp3 Bit0 kopieren
  cp Temp3,Pari              ;Parität überprüfen
  brne Aus26                 ;Fehler -> Ende
  clr Pari
  clr Buffer
Aus20:
  cpi Impuls, 35             ;35. Impuls
  brne Aus25                 ;nein -> weiter
  lsr Buffer                 ;Buffer 2x schieben, da Stunde nur 6 Bit
  lsr Buffer
  rcall Bcd2dez              ;in Dezimal wandeln
 *sts {T_Std},Buffer         ;Temp Stunde schreiben
  clr Buffer
Aus25:
  cpi Impuls, 36             ;Stunden Parität
  brne Aus30
  clr Temp3
  bst Buffer,7               ;Paritätsbit selektieren
  bld Temp3,0                ;Paritätsbit in Temp3 Bit0 kopieren
  cp Temp3,Pari              ;Parität überprüfen
  breq Aus27                 ;Pari OK -> weiter
Aus26:
  ret                        ;Fehler -> Ende
Aus27:
  set                        ;T-Bit setzen
  bld Status,4               ;Bit4 Status setzen (Parität)
  clr Buffer
Aus30:
  cpi Impuls,42              ;42. Impuls
  brne Aus40
  lsr Buffer                 ;Buffer 2x schieben, da Tag nur 6 Bit
  lsr Buffer
  rcall Bcd2dez              ;in Dezimal wandeln
  *sts {_day},Buffer         ;Tag schreiben
  clr Buffer
Aus40:
  cpi Impuls,45              ;45. Impuls
  brne Aus50
  lsr Buffer                 ;Buffer 5x schieben, da Wochentag nur 3 Bit
  lsr Buffer
  lsr Buffer
  lsr Buffer
  lsr Buffer
  rcall Bcd2dez             ;in Dezimal wandeln
 *sts {Wotag},Buffer        ;Wochentag schreiben
  clr Buffer
Aus50:
  cpi Impuls,50             ;50. Impuls
  brne Aus60
  lsr Buffer                ;Buffer 3x schieben, da Monat nur 5 Bit
  lsr Buffer
  lsr Buffer
  rcall Bcd2dez             ;in Dezimal wandeln
 *sts {_month},Buffer       ;Monat schreiben
  clr Buffer
Aus60:
  cpi Impuls,58             ;58. Impuls
  brne Aus70
  rcall Bcd2dez             ;in Dezimal wandeln
 *sts {_year},Buffer        ;Jahr schreiben
  clr Buffer
Aus70:
  cpi Impuls,59             ;59. Impuls
  brne Aus80
  set                       ;T-Bit setzen
  bld Status,3              ;Bit3 Status setzen (59 Impulse)
Aus80:
  cpi Impuls,60             ;bei mehr als 59 Impulsen (Störimpulse)
  brne Aus90          
  clt                       ;T-Bit löschen
  bld Status,3              ;Bit3 Status löschen (59 Impulse)
  bld Status,4              ;Bit4 Status löschen (Parität)  
Aus90:
  ret
;-------------------------------------------------------------------------------
Bcd2dez:
  mov Temp1,Buffer
  andi Temp1,$0F
Bcd10:
  subi Buffer,$10
  brcs Bcd20
  subi Temp1,$F6
  rjmp Bcd10
Bcd20:
  mov Buffer,Temp1
  ret 
[end]
Natürlich habe ich die Softclock im Prog konfiguriert.
Funktioniert aber leider nicht so, wie ich mir das vorgestellt hatte (nämlich gar nicht!).

Alternativ hatte ich schon Versuche mit dem CONFIG Clock = User gemacht, aber auch noch nicht sehr erfolgreich.

Ich will ja eigentlich die BASCOM-Softclock mit DATE$ und TIME$ (ohne Uhrenquarz) nutzen und sie bei Bedarf (bestimme ich selbst, wann ich Bedarf habe!) mit der DCF-Zeit updaten.

Naja, ich muss halt 'mal weiter probieren. Vielleicht geht's ja irgendwie.
Vielen Dank nochmal!

Gruß Dirk