\documentclass[11pt,a4paper]{article}

% 2006-07-07 EW Adventures-1.tex
% 2006-07-22 EW Adventures-2.tex
% 2006-08-14 EW Adventures-2a.tex
% 2007-01-10 EW Adventures-3.tex
% 2007-01-13 EW Adventures-4.tex
%
% Aufgebessert nachdem ich 'ne Reihe Optimierungen gemacht hatte
% Und dann nochmal komplett umgeräumt!
%

% language support
\usepackage[german]{babel}
%\usepackage{german}
%\usepackage[latin1]{inputenc} % can use Umlauts now "u instead of "u
%\usepackage{lmodern} % better fonts
%\usepackage{pslatex} % use native PostScript fonts
\usepackage{cm-super}

\usepackage{url} % \url{} \path{} with correct "hyphenation"
%\usepackage{fancyvrb} % for code examples

% \voffset-10mm
% \pagestyle{empty}
% \pagestyle{plain}
% \pagestyle{headings}
% \renewcommand{\baselinestretch}{1.08}
%\usepackage{xspace}
\parindent=0pt
%\newcommand{\Forth}{\textsc{forth}\xspace}
\begin{document}

\title{Adventures in Forth 4}

\author{Erich W"alde}

\maketitle

\begin{multicols}{2}

  


% ====================================================================
  \section{Eine Funkuhr}
  \label{sec:dcfclock}
  

  Im zweiten Teil (\ref{Adv2}) dieser kleinen Artikelserie wurde eine Uhr
  f"ur Steuerungsaufgaben realisiert (\texttt{timeup}). Diese Uhr wollte
  ich nun mit einem DCF-77 Empf"anger ausr"usten. Allerdings zeigte sich
  beim Programmieren, dass diese Aufgabe mehr zu einer \textit{Studie f"ur
    Designentscheidungen} geriet, als ich guthei"sen kann.

  Ich hatte noch einen arbeitslosen DCF-77 Empf"anger herumliegen. Den
  invertierten Signalpin des Empf"angers verband ich mit dem Pin 5 von Port
  D. Dieser Pin des Renesas R8C/13--Kontrollers kann auch Interrupts
  ausl"osen.

  Das DCF-Signal ist recht einfach aufgebaut. Jede Sekunde wird ein Bit
  "ubertragen. Der Wert des Bits wird durch die Dauer kodiert: ein Signal
  von 100\,ms wird als Null, ein Signal von 200\,ms wird als Eins
  interpretiert. In der 59.\ Sekunde wird kein Bit "ubertragen. Die
  f"uhrende Flanke des n"achsten Bits markiert den Beginn der neuen Minute.
  Die Daten sind als \textit{binary coded decimal} (BCD) Werte kodiert und
  das niedrigstwertige Bit wird zuerst "ubertragen. BCD bedeutet, dass in
  jeder H"alfte des Bytes eine Ziffer "ubertragen wird, also etwa
  \texttt{0x16} f"ur 16 und nicht etwa \texttt{0x10}. Die Bedeutung der
  DCF-Bits sei hier aufgelistet, soweit f"ur das Programm von Bedeutung
  (\ref{dcf}).

  \begin{tabular}[h]{r|l}
    Bit Nr. & \\ \hline
    0       & Beginn der Minute \\
    17      & Sommerzeit \\
    21--27  & Minute \\
    28      & Parit"at Minute \\
    29--34  & Stunde \\
    35      & Parit"at Stunde \\
    36--41  & Tag \\
    42--44  & Wochentag \\
    45--49  & Monat \\
    50--57  & Jahr$-2000$ \\
    58      & Parit"at \\
    59      & kein Signal \\
  \end{tabular}


  \section{Entscheidungen}

  \subsection{Eine oder zwei Uhren?}

  Ich hatte so eine DCF-Uhr vor ein paar Jahren schon einmal in
  8051-Assembler geschrieben. Damals fand ich heraus, dass das DCF-Signal
  durchaus ohne Vorwarnung \textit{ausbleibt}, und das f"ur mehrere
  Minuten. Das mag am Wetter, der Geographie oder den Unzul"anglichkeiten
  des Empf"angers liegen. Bei Gewittern ist das Signal au"serdem stark
  gest"ort. Ich will aber eine Uhr, die korrekt weiterl"auft, wenn das
  Signal ausbleibt. Also nehme ich \texttt{timeup} als Grundlage. Ganz grob
  will ich zwei Funktionen in \texttt{timeup} einh"angen. Eine Funktion
  soll \textit{oft} das Signal der DCF-Uhr abtasten und auswerten, die
  andere soll \textit{selten} die \texttt{timeup}-Uhr mit der DCF-Uhr
  synchronisieren.

  \textbf{Entscheidung 1:} Die \texttt{timeup}-Uhr l"auft unabh"angig; sie
  wird mit der DCF-Uhr gelegentlich synchronisiert.


  \subsection{Abtasten oder Interrupts?}

  Es gibt zwei M"oglichkeiten, das DCF-Signal auszuwerten. Entweder man
  tastet das Signal regelm"a"sig ab oder man l"asst jede Flanke einen
  Interrupt erzeugen, welcher die Auswertung des Signals ausl"ost. Die
  zweite Variante hat den Vorteil, dass das Programm nur dann das Signal
  auswertet, wenn es wirklich was zu tun gibt. Die erste Variante hat den
  Vorteil, dass sie einfach zu durchschauen ist. Erschwerend kam hinzu,
  dass ich bislang nicht herausgefunden habe, wie ich einem Interrupt aus
  Forth heraus eine \textit{interrupt service routine} verpasse --- die
  G"otter und die Gurus m"ogen mir verzeihen.

  \textbf{Entscheidung 2:} Das Signal wird abgetastet.

  Daran schlie"st sich sofort die Frage an, wie oft das Signal abgetastet
  wird. F"ur eine Null dauert das Signal $1/10$\,s. In dieser Zeit m"ochte
  ich das Signal vielleicht 10--mal abtasten. Dann erh"alt man normalerweise
  Z"ahlwerte von 8 oder 9. Wenn au"serdem eine Abtastung durch Rauschen
  falsch ist, dann ist das immer noch von Eins (16-19 Z"ahler) oder
  Kein-Signal (0-1 Z"ahler) gut zu unterscheiden.

  \textbf{Entscheidung 3:} Die Abtastung erfolgt mit 100\,Hz.

  Das l"asst sich sehr einfach realisieren, indem man der
  \texttt{timeup}-Uhr die entsprechenden Konstanten verpasst.

\begin{verbatim}
10  Constant cycles.tick \ timerC cycles/tick
100 Constant ticks.sec   \ ticks/second
\end{verbatim}

  Die Abtastung des Signals ruft man dann in \texttt{job.tick} auf.

  \subsection{Synchronisieren auf die Sekunde}

  In Sekunde 59 bleibt das Signal aus, die neue Minute f"angt an der Flanke
  des n"achsten Bitsignals an. Man k"onnte versucht sein, auf diese Flanke
  zu warten. Was, aber wenn diese Flanke dann ausbleibt oder durch Rauschen
  zu fr"uh vorget"auscht wird? Das hat mir auch nicht so recht gefallen.
  Also habe ich beschlossen, die \texttt{timeup}-Uhr anders an das Signal
  anzugleichen.

  Das Signal wird also 100--mal in der Sekunde gemessen. Ist der Pegel 0\,V
  (aktiv), dann wird der Pulsz"ahler erh"oht, andernfalls der
  Pausenz"ahler:

\begin{verbatim}
: dcf.readPin ( -- t/f )
  \ pin is on "active low" connection -> invert
  pinDCF portDCF btst invert
;
: dcf.tick ( -- )
  dcf.readPin

  \ count up Pulse/Pause counters
  IF
    1 dcfPulse +!
  ELSE
    1 dcfPause +!
  ENDIF
  ...
;
\end{verbatim}

  Zum Erkennen von Null, Eins und der 59.\ Sekunde reicht das aus.
  Allerdings k"onnte es sein, dass der Bitpuls so sp"at in der
  \texttt{timeup}-Sekunde losgeht, dass sein Ende bereits in der n"achsten
  Sekunde liegt. Das kann dazu f"uhren, dass "uber lange Zeit kein
  g"ultiges DCF-Telegram empfangen wird, vor allem dann, wenn eine Null noch
  innerhalb der \texttt{timeup}-Sekunde liegt, eine Eins aber in die
  n"achste Sekunde hineinreicht.

  Um das zu vermeiden, will ich feststellen, ob der Puls des Bits komplett
  im ersten Viertel der \texttt{timeup}-Sekunde liegt. Wenn nicht, dann
  kann ich das Auswerten des Bits "uber ein Offset etwas verschieben. Damit
  wird die Verschiebung der beiden Uhren zumindest gemessen. Dieses
  Verfahren ist auch einigerma"sen robust gegen St"orungen des Signals.
  
  \textbf{Entscheidung 4:} Die \texttt{timeup}-Uhr auf wenige ticks
  (10\,ms/tick) mit der DCF-Uhr synchronisiert.


  \subsection{Auswertung fortlaufend oder am Ende?}
  
  Eine weitere Frage ist die, ob man zuerst alle Bits einsammelt und die
  Information dann am Ende der Minute am St"uck auswertet oder ob man nach
  jedem Bit die Information auswertet. Auch das ist eher Geschmacksache.

  \textbf{Entscheidung 5:} Die Bits werden fortlaufend ausgewertet und nicht erst am
  Ende der Minute.

  \section{Code 1: DCF-Signal abtasten}
  
  Als Grundlage dient der Code aus dem 2.\ Teil: eine \texttt{timeup}--Uhr,
  bei der alle Teile, die mit dem i2c--Bus zu tun haben, herausgenommen
  wurden. Die Worte f"ur die DCF-Uhr befinden sich in der Datei
  \texttt{adv4\_dcf.fs}. Diese erwartet ein paar definierte Konstanten und
  die Worte \texttt{led2\_0} und \texttt{led2\_1}, um das DCF-Signal direkt
  auf LED2 anzuzeigen.

\begin{verbatim}
$e8   Constant portDCF \ port-D
$ea   Constant pddrDCF \ pddr-D
5     Constant pinDCF
: led2_0 ( -- ) 2 port1 bclr ;
: led2_1 ( -- ) 2 port1 bset ;
include adv4_dcf.fs
\end{verbatim}

  \texttt{adv4\_dcf.fs} enth"alt zun"achst drei simple Worte:

\begin{verbatim}
: dcf.readPin
  \ pin is on "active low" connection 
  \ --> invert
  pinDCF portDCF btst invert
;
: dcf.init
  pinDCF pddrDCF bclr      \ set pinDCF input
;
: dcf.tick
  dcf.readPin
  \ show DCF-Signal "active" on led2
  IF led2_1 ELSE led2_0 ENDIF
;
\end{verbatim}

  Zwei dieser Worte werden in den Innereien der \texttt{timeup}--Uhr
  aufgerufen: \texttt{dcf.init} in \texttt{loop.init} und \texttt{dcf.tick}
  in \texttt{job.tick}.
 
  Wenn man das Programm l"adt und mit \texttt{run} die Uhr startet, dann
  blinken die beiden LEDs Nr.\,2 und 3. LED Nr.\,3 blinkt im Sekundentakt,
  Puls und Pause sind gleich lang. LED Nr.\,2 blinkt wie das DCF--Signal.
  Man kann recht bald Null und Eins (leuchtet l"anger) durch blo"ses
  Hinsehen unterscheiden. Ebenso ist die Pause bei Sekunde 59 (kein Signal)
  bald gefunden.

  \section{Code 2: Bits vermessen}

  Im n"achsten Schritt werden zwei Variablen \texttt{dcfPulse} und
  \texttt{dcfPause} definiert. Mit diesen werden die L"angen von Puls
  (aktives DCF-Signal) und Pause vermessen. Au"serdem verwende ich die
  Ausgabeumleitung aus dem dritten Teil (\ref{Adv3}) f"ur die Ausgaben.

\begin{verbatim}
Variable dcfPulse
Variable dcfPause
: dcf.tick
  dcf.readPin
  \ show pin "active" on led2
  dup IF led2_1 ELSE led2_0 ENDIF

  \ count up Pulse/Pause counters
  IF
    1 dcfPulse +!
  ELSE
    1 dcfPause +!
  ENDIF

  \ reload counters if tick == 0
  tick @ 0 = IF
    to-stdout cr
    dcfPulse @ s>d 3 d.r space
    dcfPause @ s>d 3 d.r
    dcf.reload
  ENDIF
;
\end{verbatim}

  Wenn \texttt{tick} aus \texttt{adv4\_timeup.fs} gleich null ist, dann
  werden die Z"ahlerst"ande ordentlich formatiert ausgegeben und die
  Z"ahler zur"uckgesetzt. Diese Aufgaben w"urde man eigentlich in einem
  Wort \texttt{dcf.sec} erwarten, welches von \texttt{job.sec} aufgerufen
  wird. Allerdings habe ich in \texttt{dcf.tick} die M"oglichkeit, die
  Auswertung des DCF-Signals innerhalb der Minute der \texttt{timeup}-Uhr
  zu verschieben, falls das n"otig wird. \texttt{dcf.tick} produziert etwa
  folgende Ausgabe:

\begin{verbatim}
include adv4_main.fs  ok
run  ok
...
  8  92
  9  91
  8  92   <== 0 bit
 18  82   <== 1 bit
  0 100   <== sync!
...
\end{verbatim}

  Die Bitfolge des Zeitsignals ist mit dieser Ausgabe leicht zu sehen. Der
  gezeigte Abschnitt zeigt ein makelloses DCF--Signal. Aber ich brauche auf
  gest"orte Signale nie sehr lange zu warten:

\begin{verbatim}
 10  90
  9  91
 26  74   <== Störungen!
 21  79   .
 43  57   .
 17  83   .
  7  93   .
  0 100   .
  0 100   .
 10  90   .
  1  99   .
\end{verbatim}

  \section{Code 3: Bits auswerten}

  Unter der Annahme, dass \texttt{dcf.tick} tats"achlich regelm"a"sig
  aufgerufen wird, kann man aus dem Wert in \texttt{dcfPulse} auf den Wert
  des Bits schlie"sen. Au"ser den Werten 0 und 1 f"ur die Bits sollen noch
  -1 f"ur Fehler und -2 f"ur die Erkennung der 59.\ Sekunde verwendet
  werden. Bei dieser Gelegenheit soll auch ein Bit eingef"uhrt werden,
  welches das Auftreten eines Fehlers innerhalb eines Telegramms (eine
  Minute) anzeigt. Au"serdem wird in der neuen Variablen \texttt{dcfPos}
  die Position innerhalb des Datentelegramms gespeichert. 

\begin{verbatim}
Variable dcfFlags
$00 Constant dcfError
Variable dcfPos
: dcf.error.set  dcfError dcfFlags bset ;
: dcf.error.clr  dcfError dcfFlags bclr ;
: dcf.error?     dcfError dcfFlags btst ;
: dcf.init
  ...
  dcf.error.set \ error unless proven ok.
;
: dcf.bit ( pulse -- bit/error )
  dup  2 < IF ( sync59      ) -2 ELSE
  dup  6 < IF dcf.error.set   -1 ELSE
  dup 11 < IF ( bit:0       )  0 ELSE
  dup 16 < IF dcf.error.set   -1 ELSE
  dup 21 < IF ( bit:1       )  1 ELSE
    dcf.error.set             -1
  ENDIF ENDIF ENDIF ENDIF ENDIF
  swap drop
;
: .3r  s>d 3 d.r space ;
: dcf.tick
  ...
  tick @ 0 = IF
    dcfPulse @ dcf.bit
    to-stdout cr
    dcfPulse @ .3r
    dcfPause @ .3r
    dcfPos   @ .3r
    dup        .3r \ bit value
    dcf.error? .3r 
    dcf.reload

    -2 = IF \ sync detected
      dcf.error.clr
      0 dcfPos !
    ELSE
      1 dcfPos +!
    ENDIF
  ENDIF
;
\end{verbatim}

  Die Funktion \texttt{dcf.bit} bewertet den Z"ahlerstand aus
  \texttt{dcfPulse}. Wurde die Pause in der 59.\ Sekunde gefunden, dann
  wird das Fehlerbit gel"oscht und \texttt{dcfPos} zur"uckgesetzt. Die
  Ausgabe sieht dann etwa so aus.

\begin{verbatim}
  8  92   0   0  -1 
 18  82   1   1  -1 
 18  82   2   1  -1 
...
  8  92  17   0  -1 
  9  91  18   0  -1 
  0 100  19  -2  -1  <== 1. sync
 10  90   0   0   0
 19  81   1   1   0 
 19  81   2   1   0 
...
  8  92  56   0   0 
  9  91  57   0   0 
  9  91  58   0   0 
  0 100  59  -2   0  <== sync
  9  91   0   0   0 
  9  91   1   0   0 
 19  81   2   1   0 
...
\end{verbatim}


\section{Code 4: Bits zu Zahlen schmieden}

Soweit habe ich erreicht, dass das DCF-Signal abgetastet und jede
Sekunde ein Bit ausgewertet wird. Die Sekunde 59 wird ebenfalls erkannt und
\texttt{dcfPos} z"ahlt die Bitpositionen des Daten-Telegramms. Im n"achsten
Schritt geht es darum, den Bitstrom in Zahlen umzuwandeln.

Daf"ur k"onnte man einen einfachen, aber daf"ur gro"sen \texttt{case}-Block
erstellen, der das erledigt:

\begin{verbatim}
dcf.bit \ bit: 0 or 1
dcfPos @ CASE
   0 OF 0 minute ! ...                ENDOF
  21 OF IF  1 minute +! Ptoggle ENDIF ENDOF
  22 OF IF  2 minute +! Ptoggle ENDIF ENDOF
  23 OF IF  4 minute +! Ptoggle ENDIF ENDOF
  24 OF IF  8 minute +! Ptoggle ENDIF ENDOF
  25 OF IF 10 minute +! Ptoggle ENDIF ENDOF
  26 OF IF 20 minute +! Ptoggle ENDIF ENDOF
  27 OF IF 40 minute +! Ptoggle ENDIF ENDOF
  28 OF Ptoggle 
        Pset? IF dcf.error.set ENDIF
     ENDOF
  ...
  ( default: tue nichts )
ENDCASE
\end{verbatim}

Allerdings sieht man an diesem kurzen St"uck schon, dass sich die
Anweisungen ziemlich eint"onig wiederholen. Das hat mir nicht gefallen.
Eigentlich wird jedes Bit in eine Variable \textit{rotiert}, und wenn man
f"ur eine Angabe im Telegramm gen"ugend Bits zusammen hat, dann wird der
Wert abgespeichert und das Spielchen beginnt von vorne.

Um die Bitfolge korrekt auszuwerten, schreibe ich eine Tabelle. Diese
enth"alt die Bitpositionen im DCF-Telegramm, an denen ein neues Feld
beginnt: etwa den Wert 21 f"ur den Beginn der Minute.

\begin{verbatim}
create   dcfFields
0  c, \  .start
8  c, \  
16 c, \  leading flags
17 c, \  daylight savings time
18 c, \  
21 c, \  Minute
28 c, \  MinuteParity
29 c, \  Hour
35 c, \  HourParity
36 c, \  Day
42 c, \  DayOfWeek [1: Mo ... 7:So]
45 c, \  Month
50 c, \  Year-2000
58 c, \  Parity
59 c, \  .fin

16 Constant dcfFieldsN
Variable dcfFieldsI
Variable dcfCurr
ram create dcfValues dcfFieldsN allot rom
: dcf.NextField? ( dcfPos -- t/f )
  dcfFieldsI @ dcfFields + c@ 1- = 
;
\end{verbatim}

Die Variable \texttt{dcfFieldsI} enth"alt die Nummer des momentan aktiven
Felds (beginnt mit 1), also etwa 6 am Beginn des Minutenfelds, und dient
als Index. Das Wort \texttt{dcf.FieldComplete?} berechnet, ob das aktuelle
Feld vollst"andig ist. Wenn ja, dann kann ich den bislang aufgesammelten
Wert speichern, und zwar im Feld \texttt{dcfValues} unter dem gleichen
Index. Das verplempert am Anfang ein paar Byte, aber die will man
vielleicht sp"ater mal auswerten. Die Felder 0 und 1 mit den Werten 8 und
16 dienen lediglich dem Schutz von \texttt{dcfValues}, welches als
Bytearray definiert wurde, und nicht als Array von Worten (\texttt{cells}).

\begin{verbatim}
6 dcfFieldsI !  ok
dcfFields dcfFieldsI @ + c@ . 28  ok
25 dcf.FieldComplete? . 0  ok
26 dcf.FieldComplete? . 0  ok
27 dcf.FieldComplete? . -1  ok
7 dcfFieldsI !  ok
28 dcf.FieldComplete? . -1  ok
\end{verbatim}

\texttt{dcfFields} enth"alt die Anfangspositionen der Felder, weil ich dann
die relativen Bitposition in diesem Feld einfach ausrechnen kann (beim
Setzen der Bits in \texttt{dcfCurr}). Au"serdem wird auf das Feld mit dem
Index \texttt{dcfFieldsI-1} zugegriffen, daher setze ich konsequenterweise
den Startwert auf 1.

Das Resultat des Wortes \texttt{dcf.bit} wird in einem neuen Wort
\texttt{dcf.usebit} verwendet: der Bitwert wird an die richtige Bitposition
in \texttt{dcfCurr} kopiert. Wenn ein Feld vollst"andig ist, wird der Wert
von BCD in dezimal gewandelt und abgespeichert. Diese beiden Werte werden
auch an der Stelle ausgegeben, bevor \texttt{dcfCurr} gel"oscht wird.

\begin{verbatim}
: dcf.usebit ( b -- )
  CASE
    -2 OF ( sync59, reset Fields Index )
      1 dcfFieldsI !
    ENDOF
    -1 OF dcf.error.set       ( error ) ENDOF
    0 OF    ( bit value 0, do nothing ) ENDOF
    1 OF    ( bit value 1, use it     )
      \ get position of current bit in dcfCurr
      \ B: minute ones
      \ dcfPos = 21..24, dcfFieldsI = 6
      \ dcfFields[5] = 21
      \ bit pos in dcfCurr = 0..3
      dcfPos @
      dcfFields  dcfFieldsI @ 1-  +  c@
      -    
      dcfCurr bset
    ENDOF
    ( default: ) dcf.error.set
  ENDCASE

  to-stdout space space
  dcfCurr @ dup .3r bcd>dec .3r
  
  dcfPos @ dcf.FieldComplete? IF
    dcfCurr @ bcd>dec
    dcfValues dcfFieldsI @ 1- + c!
    0 dcfCurr !
    1 dcfFieldsI +!
  ENDIF
;
\end{verbatim}

Zur Belohnung erhalten wir ein komplettes Datentelegramm, hier noch von
Hand kommentiert. Alle Felder wurden richtig ausgewertet. Seit 2003 wird in
den ersten 15 Bits des Datentelegramms zus"atzliche Information
"ubertragen, davor waren dort alle Bits auf null gesetzt.

{\small
\begin{verbatim}
  0 100  59 -2  0  15  0   0  0   Sync
  9  91   0  0  0   1  0   0  0 
 18  82   1  1  0   1  0   2  2 
 18  82   2  1  0   1  0   6  6 
 17  83   3  1  0   1  0  14 14 
  8  92   4  0  0   1  0  14 14 
  9  91   5  0  0   1  0  14 14 
  8  92   6  0  0   1  0  14 14 
  9  91   7  0  0   1 -1  14 14 
 18  82   8  1  0   2  0   1  1 
 18  82   9  1  0   2  0   3  3 
 18  82  10  1  0   2  0   7  7 
 17  83  11  1  0   2  0  15 15 
  8  92  12  0  0   2  0  15 15 
  9  91  13  0  0   2  0  15 15 
  9  91  14  0  0   2  0  15 15 
  9  91  15  0  0   2 -1  15 15 
  9  91  16  0  0   3 -1   0  0 
  9  91  17  0  0   4 -1   0  0 
 18  82  18  1  0   5  0   1  1 
  8  92  19  0  0   5  0   1  1 
 18  82  20  1  0   5 -1   5  5 
  8  92  21  0  0   6  0   0  0 
  9  91  22  0  0   6  0   0  0 
 18  82  23  1  0   6  0   4  4 
  8  92  24  0  0   6  0   4  4 
  9  91  25  0  0   6  0   4  4 
 18  82  26  1  0   6  0  36 24   
  9  91  27  0  0   6 -1  36 24   24 Minuten
  9  91  28  0  0   7 -1   0  0   P.ok
 18  82  29  1  0   8  0   1  1 
 19  81  30  1  0   8  0   3  3 
  8  92  31  0  0   8  0   3  3 
  9  91  32  0  0   8  0   3  3 
  8  92  33  0  0   8  0   3  3 
 19  81  34  1  0   8 -1  35 23   23 Stunden
 19  81  35  1  0   9 -1   1  1   P.ok
  8  92  36  0  0  10  0   0  0 
  8  92  37  0  0  10  0   0  0 
  8  92  38  0  0  10  0   0  0 
  8  92  39  0  0  10  0   0  0 
 19  81  40  1  0  10  0  16 10 
 17  83  41  1  0  10 -1  48 30   30 Tag
  8  92  42  0  0  11  0   0  0 
 19  81  43  1  0  11  0   2  2 
  8  92  44  0  0  11 -1   2  2   2 Dienstag
 19  81  45  1  0  12  0   1  1 
  8  92  46  0  0  12  0   1  1 
  9  91  47  0  0  12  0   1  1 
  8  92  48  0  0  12  0   1  1 
  8  92  49  0  0  12 -1   1  1   1 Monat
 19  81  50  1  0  13  0   1  1 
 18  82  51  1  0  13  0   3  3 
 17  83  52  1  0  13  0   7  7 
  8  92  53  0  0  13  0   7  7 
  8  92  54  0  0  13  0   7  7 
  9  91  55  0  0  13  0   7  7 
  8  92  56  0  0  13  0   7  7 
  8  92  57  0  0  13 -1   7  7   07 Jahr
 19  81  58  1  0  14 -1   1  1   P.ok
  0 100  59 -2  0  15  0   0  0   Sync
\end{verbatim}
}
Ergebnis: Dienstag  2007-01-30 23:24 h.

Das war jetzt ein ordentlicher Brocken, und daran habe ich auch einige Zeit
gegr"ubelt. Und beim Schreiben des Artikels nochmal. Eine Konsequenz des
Schreibens ist, dass man sich nochmal richtig Gedanken machen muss: Warum
habe ich das jetzt so gel"ost und nicht anders? Und gelegentlich stolpert
man so auch "uber eine bessere L"osung. 

\section{Code 5: Parit"atsbits auswerten}

Um die Parit"atsbits auszuwerten, brauchen wir ein paar Worte, die das Bit
setzen, l"oschen, abfragen und umschalten. Bei jedem Datenbit, welches den
Wert 1 hat, wird das interne Parit"atsbit umgeschaltet. Wenn das
zugeh"orige Parit"atsbit aus dem Telegramm 1 ist, dann wird das interne
Parit"atsbit ebenfalls umgeschaltet. Danach muss das interne Parit"atsbit
zwangsl"aufig den Wert 0 haben.

Die Positionen der Parit"atsbits im Datentelegramm habe ich im
nachfolgenden Block hart kodiert. Wenn das interne Parit"atsbit zu den
angegebenen Stellen nicht 0 ist, wird \texttt{dcfError} gesetzt.

\begin{verbatim}
Variable dcfFlags
...
$01 Constant dcfParity

: dcf.par.set dcfParity dcfFlags bset ;
: dcf.par.clr dcfParity dcfFlags bclr ;
: dcf.par.tgl dcfParity dcfFlags 2dup
  btst IF bclr ELSE bset ENDIF ;
: dcf.par?    dcfParity dcfFlags btst ;

\ set dcf.error bit if parity bit is set
: dcf.err.if.par 
  dcf.par? IF dcf.error.set ENDIF 
  dcf.par.clr
;
: dcf.usebit
  ...
  CASE
    1 OF
      ...
      dcf.par.tgl
    ENDOF
    ( default: ) dcf.error.set
  ENDCASE

  dcfPos @
  CASE
    20 OF    dcf.par.clr ENDOF
    28 OF dcf.err.if.par ENDOF
    35 OF dcf.err.if.par ENDOF
    58 OF dcf.err.if.par ENDOF
  ENDCASE
  ...
;
\end{verbatim}

Jetzt ist es an der Zeit, die empfangenen Werte anzuzeigen.


\begin{verbatim}
: get.DCF ( -- S M H d m Y )
  0                          \ fake second
  dcfValues  5  + c@         \ minute
  dcfValues  7  + c@         \ hour  
  dcfValues  9  + c@         \ day   
  dcfValues 11  + c@         \ month 
  dcfValues 12  + c@ 2000 +  \ year  
;
\end{verbatim}

Das Wort \texttt{get.DCF} liest die Werte aus dem \texttt{dcfValues}-array
und legt sie auf den Stapel. Zur Ausgabe
benutze ich das schon vorhandene Wort \texttt{show.DT}. Die Ausgabe wird in
dcf.tick gemacht, in dem Block \texttt{tick @ 0 = IF ... ENDIF}. Ein
fehlerfreies Telegramm vorausgesetzt, erscheint jetzt auch ein ordentlich
formatierter Zeitstempel in den Ausgaben:

{\small
\begin{verbatim}
...
  9  91  57   0   0    13  -1     7   7   0 
  9  91  58   0   0    14  -1     0   0   0 
  0 100  59  -2   0    15   0     0   0   0 
20070201-224700
  9  91   0   0   0     1   0     0   0   0 
  9  91   1   0   0     1   0     0   0   0 
...
\end{verbatim}
}

Danach kann man sich von den l"anglichen Debugausgaben verabschieden. Die
habe ich mit einem weiteren Bitflag verziert. So kann man das bequem am
laufenden Programm ein- und ausschalten.

\begin{verbatim}
Variable dcfFlags
...
$0f Constant dcfDebug
: dcf.D? dcfDebug dcfFlags btst ;

...
  dcf.D? IF
    to-stdout
    ...      
  ENDIF
...
\end{verbatim}


\begin{verbatim}
dcf error
dcf error
20070201-225100
20070201-225300
20070201-225400
20070201-225500
20070201-225600
...
\end{verbatim}

\section{Code 6: \texttt{timeup}-Uhr stellen}

Jetzt sind alle Zutaten bereit, um die vom DCF-Signal gewonnene Zeit auf
die \texttt{timeup}-Uhr zu "ubertragen. Dazu f"uhre ich ein weiteres Bit
namens \texttt{dcfCommit} ein. Dieses wird von \texttt{dcf.init} und
danach jede Stunde von \texttt{job.hour} gesetzt. Am Ende von
\texttt{dcf.tick} wird die Zeit aus dem DCF-Signal auf die Z"ahler von
\texttt{timeup} kopiert, wenn Sekunde 59 erkannt wurde und wenn
\texttt{dcfCommit} gesetzt ist und wenn das Telegramm fehlerfrei war.
Dabei muss man bedenken, dass die \texttt{timeup}-Uhr die Z"ahler f"ur Tag
und Monat um Eins erniedrigt benutzt. Danach wird \texttt{dcfCommit}
gel"oscht.

\begin{verbatim}
: dcf.commit ( -- )
  get.DCF
  year     !
  1- month !
  1- day   !
  hour     !  
  min      !
  sec      ! \ zero
;

: dcf.init
  ...
  dcfCommit dcfFlags bset \ commit requested
;
: dcf.tick
  ...
  tick @ 0 = IF
    ...
    -2 = IF \ sync detected
      to-stdout cr 
      dcf.error? invert IF
        get.DCF
        show.DT
        dcfCommit dcfFlags btst IF
          dcfCommit dcfFlags bclr
          dcf.commit
        ENDIF
      ELSE
        ." dcf error "
      ENDIF
      dcf.error.clr
      0 dcfPos !
      0 dcfCurr !
    ELSE
      1 dcfPos +!
    ENDIF
  ENDIF
;
...
: job.hour
  dcfCommit dcfFlags bset
;
\end{verbatim}


Damit haben wir eine einigerma"sen funktionierende DCF-Uhr. Der Code belegt
etwa 3520 Bytes (nach savesystem). \textit{Einigerma"sen} bedeutet, dass
unter ung"unstigen Bedingungen das DCF-Signal nicht korrekt lesen kann und
die Uhr lange Zeit braucht, bis sie sich gestellt hat.

\section{Code 7: \texttt{dcfOffset}}

Wenn man zu lang das Blinken der LEDs und die
Anzeige der Uhrzeit anstarrt, dann findet man, dass die \texttt{timeup}-Uhr
zu langsam (oder zu schnell, abh"angig vom Quarz) l"auft. Die
Fabrikationstoleranz der Quarze zeigt sich hier deutlich. Daher
habe ich ein Offset eingef"uhrt, welches die Verschiebung des DCF-Signals
gegen die \texttt{timeup}-Uhr beinhaltet (maximal 100 ticks, also 1
Sekunde). Die Verschiebung betr"agt bei mir ca.\ 0.15 Sekunden in der Stunde.
Beim "Ubertragen der DCF-Zeit wird diese Verschiebung ausgeglichen, siehe
Entscheidung 4.

Der Aufwand ist betr"achtlich. Zun"achst sind 2 Variablen zu
definieren: \texttt{dcfOffset} enth"alt die Verschiebung der DCF-Sekunde
gegen die \texttt{timeup}-Sekunde. Die erlaubten Werte sind \texttt{0} bis
\texttt{ticks.sec-1}. Alle Abfragen von der Bauart
\verb|tick @  [Zahl]  =  IF ...|
werden ge"andert in
\verb|tick @  [Zahl] dcfOffset @ +  ticks.sec mod =|
Wichtig ist dabei die Modulo--Operation, denn negative oder zu gro"se Werte
erreicht \texttt{tick} nun mal nicht.

In \texttt{dcf.tick} wird nach dem Hochz"ahlen der Wert von
\texttt{dcfPulse} in \texttt{dcfPulse1} gespeichert, falls
\texttt{dcfOffset1} ticks verstrichen sind (Aufruf von
\texttt{dcfCountPP}). Damit kann ich feststellen, ob der DCF-Puls am Anfang
der mit \texttt{dcfOffset} festgelegten Sekunde liegt. Falls nicht, wird
\texttt{dcfOffset} angepasst (Aufruf von \texttt{dcf.check.offset}).

Wenn man \texttt{dcfOffset} um \texttt{1} erh"oht, dann wird der mit 
\verb|tick @ dcfOffset @ ticks.sec mod = IF ... ENDIF| eingefasste Block
beim n"achsten tick wieder ausgef"uhrt, obwohl nur ein einziger tick
verstrichen ist. Um das zu vermeiden, bekommt \texttt{dcf.bit} einen
weiteren R"uckgabewert, welcher diesen Fall anzeigt. In \texttt{dcf.tick}
wird alles nach dem Aufruf von \texttt{dcf.bit} entsprechend abgesichert:
\verb|dup -3 <> IF ... ELSE drop ENDIF|.

\begin{verbatim}
Variable dcfOffset
Variable dcfPulse1
21 Constant dcfOffset1

: dcf.commit ( -- )
  0 tick !
  0 dcfOffset !
  get.DCF
  ...
  ."  commited "
;

: dcf.reload
  ...
  0 dcfPulse1 !
;

: dcf.bit ( pulse pause -- bit/error )
  \ return values:
  \ -3 interval too short
  \ -2 sync detected
  \ -1 error
  \  0 bit value 0
  \  1 bit value 1
  \ limits hardcoded assuming 10 ms per count
  2dup + 97 > IF
    drop
    dup  2 < IF ( ." sync59 " ) -2 ELSE
    dup  6 < IF dcf.error.set   -1 ELSE
    dup 11 < IF ( ." bit:0 "  )  0 ELSE
    dup 16 < IF dcf.error.set   -1 ELSE
    dup 21 < IF ( ." bit:1 "  )  1 ELSE
    dcf.error.set             -1
    ENDIF ENDIF ENDIF ENDIF ENDIF
    swap drop
  ELSE
    2drop -3
  ENDIF
;

: dcf.usebit ( b -- )
  CASE
    ...
    1 OF    ( bit value 1, use it )
      dcf.error? invert IF
        \ position of current bit in dcfCurr
        ...
        dcf.par.tgl
      ENDIF
    ENDOF
    ...
  ENDCASE

  dcfPos @ dcf.FieldComplete? IF
    dcfCurr @ bcd>dec
    dcfValues dcfFieldsI @ 1- + c!
    0 dcfCurr !

    dcfFieldsI @ 1+
    dup dcfFieldsN < invert IF drop 1 ENDIF
    dcfFieldsI !
  ENDIF
;

: dcfCountPP
  tick @ dcfOffset1 dcfOffset @ + ticks.sec mod =
  IF dcfPulse @ dcfPulse1 ! ENDIF
;

: dcf.tick
  dcf.readPin

  \ show pin "active" on led2
  dup IF led2_1 ELSE led2_0 ENDIF

  \ count up Pulse/Pause counters
  IF    1 dcfPulse +!
  ELSE  1 dcfPause +!
  ENDIF
  dcfCountPP
  
  \ reload counters if tick == 0
  tick @ ( 0 ) dcfOffset @ ( + ) ticks.sec mod = IF
    dcfPulse @ dcfPause @ dcf.bit

    dup -3 <> IF \ unless interval too short
      
      dup dcf.dbg.out  \ print counters
    
      dup dcf.usebit   \ print dcfCurr bcd, dec
      dup 0 >= IF      \ check dcfOffset if valid
        dcf.check.offset
      ENDIF
      dcf.reload       \ clear counters

      -2 = IF \ sync detected
        to-stdout cr 
        dcf.error? invert IF
          get.DCF
          show.DT
          dcfPos @ 59 =
          dcfCommit dcfFlags btst
          and IF
            dcfCommit dcfFlags bclr
            dcf.commit
          ENDIF
        ELSE
          ." dcf error "
        ENDIF
        dcf.error.clr
        0 dcfPos !
        0 dcfCurr !
        1 dcfFieldsI !
      ELSE
        \ 1 dcfPos +!
        \ assert 0 .. 59!
        dcfPos @ 1+ 60 mod dcfPos !
      ENDIF
    ELSE
      drop
    ENDIF
  ENDIF
;
\end{verbatim}

Das ist nochmal ein ordentlicher Brocken. Man kann das bestimmt auch anders
machen, wie alles. Aber so hat es mir am besten gefallen. Das Programm
belegt 3722 Byte und nach \verb|rom ' run is bootmessage ram savesystem|
4006 Byte. Wenn die Uhr noch irgendetwas anderes k"onnen soll, dann ist
wohl erst mal Code aufr"aumen angesagt.

\section{Ausblick}

Ein paar Dinge k"onnte man jetzt noch tun:

\begin{itemize}
\item die Debugausgaben aus dem Programm entfernen, um Platz zu schaffen
\item man k"onnte den Zustand von \texttt{dcfError} auf dem LCDisplay
  anzeigen
\item Geschickt w"are auch ein Zeichen, welches die Sommerzeit anzeigt
\item Schaltsekunden werden derzeit nicht ber"ucksichtigt
\item dcfOffset auf dem LCDisplay anzeigen\\
  \verb+lcdpos 1 0 dcfOffset @ s>d 4 d.r+ in \texttt{job.sec}
\end{itemize}
 

M"oglicherweise k"onnte man dem Kontroller einen externen Uhrenquarz oder
Oszillator spendieren, um das Problem mit der Drift zu l"osen.

Diese Uhr ist \textit{nur eine Uhr} --- keine DCF-synchronisierte
Hauszentrale. Dazu reicht leider der Platz nicht so recht, selbst wenn man
die nicht mehr ben"otigten Teile des Programms entfernt. Auch die
Geschichte mit dem Sonnenscheinsensor muss noch etwas warten. Erg"anzungen,
Kommentare, Korrekturen sind ausdr"ucklich erw"unscht. Sie erreichen mich
unter \url{ew.forth@nassur.net}

\section{Referenzen}

\begin{enumerate}
\item \label{adv4:Adv1} E. W"alde, Adventures in Forth, Die 4. Dimension 3/2006, Jahrgang 22
\item \label{adv4:Adv2} E. W"alde, Adventures in Forth 2, Die 4. Dimension 4/2006, Jahrgang 22
\item \label{adv4:Adv3} E. W"alde, Adventures in Forth 3, Die 4. Dimension 1/2007, Jahrgang 23
%\item \label{adv4:Adv4} E. W"alde, Adventures in Forth 4, Die 4. Dimension 1/2007, Jahrgang 23
\item \label{r8c-ds} Renesas R8C/13 datasheet auf \url{www.renesas.com}
%\item \label{Koenig} A.\ K"onig und M.\ K"onig, Das PICmicro Profi Buch, Franzis
%  Verlag 1999, ISBN 3-7723-4284-1
%\item \label{SPelc} Stephen Pelc, Programming Forth, \\ \url{http://www.mpeforth.com/arena/ProgramForth.pdf}
%\item \label{Deliano} \url{http://www.embeddedforth.de/emb3.pdf} S.\ 9
\item \label{dcf} \url{http://de.wikipedia.org/wiki/DCF77} und Verweise darin
\end{enumerate}
\end{multicols}

\section{Listings}
\begin{quote}
\begin{small}
\begin{multicols}{2}
\listinginput[1]{1}{2007-01/adv4_main.fs}      % main loop, jobs
\listinginput[1]{1}{2007-01/adv4_dcf.fs}       % . dcf Uhr
\listinginput[1]{1}{2007-01/adv4_timeup.fs}    % . timeup Uhr
\listinginput[1]{1}{2007-01/adv4_lcd.fs}       % . Formatierung fürs LCD
\listinginput[1]{1}{2007-01/adv4_redir.fs}     % . output redirection
\listinginput[1]{1}{2007-01/adv4_tasker.fs}    % . tasker
\end{multicols}
\end{small}
\end{quote}


\end{document}
