PZF Folge – Verdandi-ntp.de

PZF Berechnen

Möchte man mit der PZF Technik experimentieren, stellt sich schnell raus das die Bitfolge warum auch immer nirgends offiziell Öffentlich gemacht wurde. In den Archiven der PTB-Mitteilungen findet sich allerdings ein Bild zu dem oben beschriebenen Schieberegister mit zwei XOR-Gattern sowie einem OR-Gatter.

PZF-Generator

In einem Buch von 1988 über das ‚Fünftes Darmstädter Kolloquium‘ mit dem Namen ‚Funkuhrtechnik‘ unter der ISBN ‚3-486-20623-0‘ findet sich noch eine weitere Zeichnung. An der Stelle wird auch die Funktion des Flip-Flops wie folgt erklärt: Beim Start ist das Schiebregister genullt. Das Flip-Flop hat nach Start eine Eins geladen. Beim ersten Takt wird die Eins in das erste Bit des Registers geschoben. Da dadurch der Ausgang von Bit 1 auf High wechselt, wird das Flip-Flop wiederum auf null gesetzt. Der Null Zustand bleibt bis zu einem Reset erhalten, so dass ab dem ersten Takt nur die Bits 5 und 9 am Eingang des Schieberegisters zählen.
Das Flip-Flop dient also nur als ‚Starthilfe‘ um eine erste 1 in das Register zu bekommen.
Um den Generator in Software abzubilden kann also vollständig auf das Flipflop verzichtet werden, in dem beim ersten Takt 0x01 geladen wird
Diese Zeichnung habe ich mal mit den heute gültigen DIN-Symbolen nachgezeichnet inklusive der Beschreibung, die dort dabei steht.

pzf-generator2

Die einzig vollständige Bitfolge habe ich in einer Diplomarbeit gefunden. Ist die Frage ob es sinnvoll ist in den Angaben blind zu vertrauen, denn Tipp oder Druckfehler schleichen sich schnell ein.

In der englischen Wikipedia findet sich ein Schnipsel C Code, welcher sich allerdings nicht einwandfrei kompilieren lies.

Daher habe ich aus den 3 Quellen den Wikipedia Code so abgeändert das gleich ein formatiertes Array rauskommt. Es ist ein anderer Ansatz da das Schieberegister an den Bits 5 & 9 vorgeladen wird, aber die Ergebnisse sind mit der Diplomarbeit zu 100% identisch. Also kein Druck oder Tippfehler in der PDF-Datei.
Daraus ergeben sich nun mindestens 2 Ansätze, um die Bitfolge zu generieren. Start bei 0 mit XOR-Gatter oder mit einem Vorlade Wert von Dezimal 272.
Vielleicht kann jemand mit dem Code in das Register geladen wird etwas anfangen, um sich z.B ein anderes Register nachzubauen:

/*
* Erzeugung der DCF77, PZF durch:
* Simulation eines Linearen 9 Bit Schieberegister mit
* XOR Rueckkoppelung an Bit 5 und Bit 9.
* Bit 5 und 9 sind mit '1' vorgeladen (100010000) =^ 0x110.
* Bit 000 Zeile ignorieren!
* 512 Bit aus jeweils 256 '0' und 256 '1'.
*/

#include <stdio.h>       // Ausgabe im Terminal.

unsigned short i, null, eins, lfsr, ausgang_chip;

int main(void) {

    // Die berechneten PZF in Datei als (Arduino) Codeblock schreiben.
    // Man ist ja Faul. 3Durchgänge um sich das Komma setzen zu ersparen...
    FILE *fp;
    fp = fopen("Bitfolge-pzf.txt", "w");
    if(fp == NULL) {
        printf("Datei konnte nicht geoeffnet werden.\n");
    }else{
        fprintf(fp, "const PROGMEM uint8_t pzf[] = {\r\n");
    }
    //----------------------------------------------------------------

    i = 0;
    lfsr = 0;

    for (i=0; i<1; i++) {
    ausgang_chip = lfsr & 1;                        // Erst eine '1' auf den Ausgang legen; dann:
    lfsr >>= 1;                                     // 1 Stelle nach Rechts, zum Eingang Shiften.
    if (ausgang_chip || !lfsr)
        lfsr ^= 0x110;                              // Schieberegister Bits 5 und 9 auf '1', 272_dez, 1 0001 0000_bin.
        printf("Nichts, Bit0 Durchlauf..\r\n");     // Nur Hinweis in Konsole, Wert/Bit 0 ist Startwert.
    }

    for (i > 0; i<=511; i++) {
    ausgang_chip = lfsr & 1;
    lfsr >>= 1;
    if (ausgang_chip || !lfsr)
        lfsr ^= 0x110;
    if (ausgang_chip==0) {
        null++;
        } else {
        eins++;
    }
    printf("Bit: %.3u  PZF: %u  REGdez:%u\r\n", i, ausgang_chip, lfsr);
    fprintf(fp, "%u,", ausgang_chip);
    }

    for (i<=511; i<=512; i++) {
    ausgang_chip = lfsr & 1;
    lfsr >>= 1;
    if (ausgang_chip || !lfsr)
        lfsr ^= 0x110;
    if (ausgang_chip==0) {
        null++;
    } else {
        eins++;
    }
        printf("Bit: %.3u  PZF: %u  REGdez:%u\r\n", i, ausgang_chip, lfsr);
        fprintf(fp, "%u", ausgang_chip);            // hier kein ',' am Ende!
    }

    fprintf(fp, "};\r\n /* Jeweils %d * eine '0' und %d * '1'.\r\n * Anfang und Ende mit 136dez (2^9-1 = 511_Bit)*/\r\n", null, eins);
    fclose(fp);
 return 0;
}

Das Ergebnis von beiden Ansätzen:

0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,0,0,1,1,1,0,0,1,0,1,0,1,0,1,1,0,0,
0,0,1,1,0,1,1,1,1,0,1,0,0,1,1,0,1,1,1,0,0,1,0,0,0,1,0,1,0,0,0,0,
1,0,1,0,1,1,0,1,0,0,1,1,1,1,1,1,0,1,1,0,0,1,0,0,1,0,0,1,0,1,1,0,
1,1,1,1,1,1,0,0,1,0,0,1,1,0,1,0,1,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,
1,1,0,0,0,1,1,0,0,1,0,1,0,0,0,1,1,0,1,0,0,1,0,1,1,1,1,1,1,1,0,1,
0,0,0,1,0,1,1,0,0,0,1,1,1,0,1,0,1,1,0,0,1,0,1,1,0,0,1,1,1,1,0,0,
0,1,1,1,1,1,0,1,1,1,0,1,0,0,0,0,0,1,1,0,1,0,1,1,0,1,1,0,1,1,1,0,
1,1,0,0,0,0,0,1,0,1,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,0,1,0,0,0,0,0,
0,1,0,1,0,0,1,0,1,0,1,1,1,1,0,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,0,1,
1,1,0,0,1,1,1,0,1,0,0,1,0,0,1,1,1,1,0,1,0,1,1,1,0,1,0,1,0,0,0,1,
0,0,1,0,0,0,0,1,1,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0,1,1,0,1,1,0,0,
1,1,0,1,0,0,0,0,1,1,1,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,
0,0,1,1,1,1,0,1,1,1,1,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0,1,0,0,0,0,0,
1,0,0,1,0,1,0,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,1,0,0,1,1,1,1,1,0,0,
1,1,0,1,1,0,0,0,1,0,1,0,1,0,0,1,0,0,0,1,1,1,0,0,0,1,1,0,1,1,0,1,
0,1,0,1,1,1,0,0,0,1,0,0,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0