CCPRO M128: DCF Clock 2 (CompactC)

[Dirk]

Hier noch der 2. Teil:

Bibliothek (RP6DCFClockCClib.cc), Teil 2:

/**
* DCF DECODER
*
* Dies ist der DCF77 Decoder.
*
* Der (abschaltbare) DCF Decoder in dieser Funktion decodiert die
* DCF Informationen und stellt die Uhr mit den empfangenen Daten.
*
* Die Funktion decodeDCF() muss alle 10ms aufgerufen werden.
*
*/
void decodeDCF(void)
{byte temp, dcfbit;
static byte impulsdauer, alterpegel, paritaet;
static byte dcfbitzaehler, dcfbitpuffer;
#ifdef WETTER
static unsigned int wetterpuffer;
#endif
static byte jahrpuffer, monatpuffer, wochentagpuffer, tagpuffer;
static byte sommerzeitpuffer, stundepuffer, minutepuffer, dcfflagspuffer;
if (!(dcfstatus & STATUS_DCF_AN)) {
return; // DCF Decoder AUS!
}
// DCF77 Decoder:
temp = Port_ReadBit(DCF_IN); // DCF Eingang lesen
if (temp == alterpegel) { // Keine Pegeländerung
impulsdauer++;
if (impulsdauer >= (PAUSE_1900MS + (PAUSE_ABWEICHUNG * 3))) {
impulsdauer = 0;
dcfstatus = dcfstatus | STATUS_FEHLER;
}
return; // Ende DCF Decoder!
}
else { // Pegeländerung am Eingang
#ifdef REPARATUR
// Nach 1ms Port neu lesen zum Erkennen von "Spikes":
// (Spikes sind kurze Störsignale von elektr. Geräten)
AbsDelay(1); // 1ms Verzögerung
if (temp != Port_ReadBit(DCF_IN)) { // Keine Pegeländerung
impulsdauer++;
return;
}
#endif
alterpegel = temp;
dcfbit = BIT_FEHLER;
if ((impulsdauer >= (PAUSE_900MS - PAUSE_ABWEICHUNG))
&& (impulsdauer < (PAUSE_900MS + PAUSE_ABWEICHUNG))) {
dcfbit = BIT_0; // Bit 0 decodiert
#ifdef DEBUG
pause_0_laenge = impulsdauer;
#endif
}
if ((impulsdauer >= (PAUSE_800MS - PAUSE_ABWEICHUNG))
&& (impulsdauer < (PAUSE_800MS + PAUSE_ABWEICHUNG))) {
dcfbit = BIT_1; // Bit 1 decodiert
paritaet++;
#ifdef DEBUG
pause_1_laenge = impulsdauer;
#endif
}
if ((impulsdauer >= (PAUSE_1900MS - PAUSE_ABWEICHUNG))
&& (impulsdauer < (PAUSE_1900MS + PAUSE_ABWEICHUNG))) {
dcfbit = LETZTESBIT_0; // Letztes Bit 0 decodiert
#ifdef DEBUG
letztepause_0_laenge = impulsdauer;
#endif
}
if ((impulsdauer >= (PAUSE_1800MS - PAUSE_ABWEICHUNG))
&& (impulsdauer < (PAUSE_1800MS + PAUSE_ABWEICHUNG))) {
dcfbit = LETZTESBIT_1; // Letztes Bit 1 decodiert
paritaet++;
#ifdef DEBUG
letztepause_1_laenge = impulsdauer;
#endif
}
impulsdauer = 0; // Impulsdauer zurücksetzen
if (dcfbit != BIT_FEHLER) { // Kein DCF Bitfehler
dcfbitpuffer = dcfbitpuffer >> 1; // Puffer nach rechts schieben
dcfbitpuffer = dcfbitpuffer | (dcfbit & 0x80); // DCF Bit einfügen
switch (dcfbitzaehler) {
#ifdef WETTER
case 7 :
wetterpuffer = dcfbitpuffer; // Wetter Infos (Bits 0..7)
if (wetterpuffer & 0x0001) { // DCF Bit 0 == 1 ?
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
dcfbitpuffer = 0; break;
#endif
case 14 :
#ifdef WETTER // Wetter Infos (Bits 8..14)
wetterpuffer = wetterpuffer | (dcfbitpuffer << 7);
#endif
dcfstatus = dcfstatus & (~STATUS_TELEGRAMMINTAKT);
dcfbitpuffer = 0; break;
case 20 :
dcfflagspuffer = dcfbitpuffer >> 2; // DCF Flags
if (dcfflagspuffer & FLAG_Z1) { // Z1: Zeitzone
sommerzeitpuffer = 1; // [1 = MESZ]
if (dcfflagspuffer & FLAG_Z2) { // Z1 == Z2 ?
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
}
else {
sommerzeitpuffer = 0; // [0 = MEZ]
if (!(dcfflagspuffer & FLAG_Z2)) { // Z1 == Z2 ?
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
}
if (!(dcfflagspuffer & FLAG_S)) { // Start Bit == 0 ?
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
dcfbitpuffer = 0;
paritaet = 0; break;
case 27 :
minutepuffer = BCDtoDEC(dcfbitpuffer >> 1); // Minute
if (minutepuffer > 59) { // Minute > 59 ?
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
break;
case 28 :
if (!(paritaet & 1)) { // P1: Parität ok ?
dcfstatus = dcfstatus | STATUS_MINPARITAET;
}
dcfbitpuffer = 0;
paritaet = 0; break;
case 34 :
stundepuffer = BCDtoDEC(dcfbitpuffer >> 2); // Stunde
if (stundepuffer > 23) { // Stunde > 23 ?
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
break;
case 35 :
if (!(paritaet & 1)) { // P2: Parität ok ?
dcfstatus = dcfstatus | STATUS_STDPARITAET;
}
dcfbitpuffer = 0;
paritaet = 0; break;
case 41 :
tagpuffer = BCDtoDEC(dcfbitpuffer >> 2); // Tag
if ((tagpuffer == 0) || (tagpuffer > 31)) {
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
dcfbitpuffer = 0; break;
case 44 :
wochentagpuffer = dcfbitpuffer >> 5; // Wochentag
if ((wochentagpuffer == 0) || (wochentagpuffer > 7)) {
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
dcfbitpuffer = 0; break;
case 49 :
monatpuffer = BCDtoDEC(dcfbitpuffer >> 3); // Monat
if ((monatpuffer == 0) || (monatpuffer > 12)) {
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
dcfbitpuffer = 0; break;
case 57 :
jahrpuffer = BCDtoDEC(dcfbitpuffer); // Jahr
if (jahrpuffer > 99) {
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
break;
case 58 :
dcfstatus = dcfstatus | STATUS_DCFBIT58;
if (!(paritaet & 1)) { // P3: Parität ok ?
dcfstatus = dcfstatus | STATUS_DATPARITAET;
}
break;
case 59 : // Schaltsekundenbit
if ((dcfbitpuffer & 0x80) || (!(dcfflagspuffer & FLAG_A2))) {
dcfstatus = dcfstatus | STATUS_FEHLER; // -> Fehler!
}
break;
case 60 : // Mehr als 59 Bits?
dcfstatus = dcfstatus & (~STATUS_DCFBIT58); // -> Fehler!
}
if (dcfbit & LETZTESBIT_0) { // Ein letztes Bit (Telegrammende):
if ((!(dcfstatus & STATUS_FEHLER))
&& (dcfstatus & STATUS_MINPARITAET)
&& (dcfstatus & STATUS_STDPARITAET)
&& (dcfstatus & STATUS_DATPARITAET)
&& (dcfstatus & STATUS_DCFBIT58)) { // Telegramm fehlerfrei?
dcfstatus = dcfstatus | STATUS_TELEGRAMMINTAKT; // Ja!
validitaetszaehler++;
if (validitaetszaehler >= validitaetsgrenze) {
validitaetszaehler = validitaetsgrenze;
#ifdef WETTER
DCF_WEATHER = wetterpuffer;
#endif
dcfflags = dcfflagspuffer;
Clock_SetTime(stundepuffer, minutepuffer, 0,
CLOCK_CORR); // Uhr stellen!
DCF_DST = sommerzeitpuffer;
DCF_DOW = wochentagpuffer;
tagpuffer--; // Tag und Monat
monatpuffer--; // ... nullbasiert!
Clock_SetDate(tagpuffer, monatpuffer, jahrpuffer);
dcfstatus = dcfstatus | STATUS_UHRGESTELLT;
}
}
else { // Telegramm NICHT intakt oder plausibel:
validitaetszaehler = 0; // Validitätszähler zurücksetzen
}
// Vorbereitung auf nächstes DCF Telegramm:
dcfstatus = dcfstatus & (~(STATUS_FEHLER | STATUS_MINPARITAET
| STATUS_STDPARITAET | STATUS_DATPARITAET
| STATUS_DCFBIT58)); // 5 Status Bits löschen
dcfbitpuffer = 0;
dcfbitzaehler = 0;
}
else { // Kein Telegramm Ende:
dcfbitzaehler++; // Nächstes DCF Bit decodieren
}
} // Kein DCF Bitfehler
} // Pegeländerung am Eingang
}

/************************************************** ****************************/
// Nützliche LCD Funktionen:

/**
* SHOW CLOCK
*
* Format: Uhrzeit
* Datum
*
*/
void showCLOCK(void)
{byte temp;
setCursorPosLCD(0, 1); // Zeile 1
temp = Clock_GetVal(CLOCK_HOUR);
if (temp < 10) {
writeCharLCD('0');
}
printIntegerLCD(temp);
writeCharLCD(':');
temp = Clock_GetVal(CLOCK_MIN);
if (temp < 10) {
writeCharLCD('0');
}
printIntegerLCD(temp);
writeCharLCD(':');
temp = Clock_GetVal(CLOCK_SEC);
if (temp < 10) {
writeCharLCD('0');
}
printIntegerLCD(temp);
if (dcfstatus & STATUS_UHRGESTELLT) {
if (DCF_DST) { // MESZ?
printLCD(" MESZ");
}
else {
printLCD(" MEZ");
}
}
setCursorPosLCD(1, 1); // Zeile 2
switch (DCF_DOW) { // Wochentag
case 1 : printLCD("Mo"); break;
case 2 : printLCD("Di"); break;
case 3 : printLCD("Mi"); break;
case 4 : printLCD("Do"); break;
case 5 : printLCD("Fr"); break;
case 6 : printLCD("Sa"); break;
case 7 : printLCD("So"); break;
default : printLCD("--");
}
printLCD(", ");
temp = Clock_GetVal(CLOCK_DAY) + 1; // Tag nullbasiert!
if (temp < 10) {
writeCharLCD('0');
}
printIntegerLCD(temp);
writeCharLCD('.');
temp = Clock_GetVal(CLOCK_MON) + 1; // Monat nullbasiert!
if (temp < 10) {
writeCharLCD('0');
}
printIntegerLCD(temp);
printLCD(".20");
temp = Clock_GetVal(CLOCK_YEAR);
if (temp < 10) {
writeCharLCD('0');
}
printIntegerLCD(temp);
}

/**
* SHOW STATUS
*
* Format: Status
* Uhrzeit
*
*/
void showSTATUS(void)
{byte i, temp;
setCursorPosLCD(0, 1); // Zeile 1
printLCD("Stat: ");
temp = dcfstatus;
for(i = 0; i < 8; i++) {
if (temp & 0x80) {
writeCharLCD('1');
}
else {
writeCharLCD('0');
}
temp = temp << 1;
}
setCursorPosLCD(1, 1); // Zeile 2
temp = Clock_GetVal(CLOCK_HOUR);
if (temp < 10) {
writeCharLCD('0');
}
printIntegerLCD(temp);
writeCharLCD(':');
temp = Clock_GetVal(CLOCK_MIN);
if (temp < 10) {
writeCharLCD('0');
}
printIntegerLCD(temp);
writeCharLCD(':');
temp = Clock_GetVal(CLOCK_SEC);
if (temp < 10) {
writeCharLCD('0');
}
printIntegerLCD(temp);
if (dcfstatus & STATUS_UHRGESTELLT) {
if (DCF_DST) { // MESZ?
printLCD(" MESZ");
}
else {
printLCD(" MEZ");
}
}
}

#ifdef DEBUG
/**
* SHOW DEBUG INFO
*
*/
void showDEBUGINFO(void)
{
setCursorPosLCD(0, 1); // Zeile 1
printLCD("P1/0: ");
printIntegerLCD(pause_1_laenge);
printLCD(" / ");
printIntegerLCD(pause_0_laenge);
printLCD(" ");
setCursorPosLCD(1, 1); // Zeile 2
printLCD("L1/0: ");
printIntegerLCD(letztepause_1_laenge);
printLCD(" / ");
printIntegerLCD(letztepause_0_laenge);
printLCD(" ");
}
#endif

/************************************************** ****************************
* Info
* ************************************************** **************************
* Changelog:
* - v. 1.0 (initial release) 13.06.2009 by Dirk
*
* ************************************************** **************************
*/

/************************************************** ***************************/
// EOF


Gruß Dirk