Zur Übersicht - INFO - Neueste 50 Beiträge - Neuer Beitrag - Suchen - Zum C-Control-I-Forum - Zum C-Control-II-Forum

Re: Bug in DemoProg DCF ? Kategorie: CC-Pro Unit & Appl.Board (von Peter S - 6.07.2005 0:13)
Als Antwort auf Bug in DemoProg DCF ? von ChristianK - 3.07.2005 20:39
Ich nutze:
C-Control Pro Mega32, CC-Pro 32 Application Board
Sorry, aber uns ist wahrscheinlich die falsche Version der Library in das Update gekommen.
Hier ein schnelles Update, was aber nur kurz getestet wurde, um allen schnell Anhilfe zu schaffen.
Bitte den folgenden Text als "DCF_Lib.cc" in das Verzeichnis "Libraries" kopieren.

Gruss Peter

----------------------------

/**************************************************************************
 DCF77 Library
***************************************************************************/
// DCF Input Signal at PortD.7
#define DCF_IN 31

byte cnt1;
byte Sekunde, Minute, Stunde;
byte Tag, Monat, Jahr;

// DCF DATA
byte CNT8;
byte Shift_CNT;
byte DCF_MODE;
byte DCF_DATA;
byte BIT_CNT;
byte SEC_CNT;
byte DATA_CNT;
byte DCF_PARITY;
byte DCF_ARRAY[7];
int ARRAY_INDEX;
word DCF_LIMIT_CNT;
//-------------------------------------------------------------------------

void Write2Digits(byte val)
{
    char num[3];

    Str_WriteWord(val,10,num,0,2);
    Msg_WriteText(num);
}

//-------------------------------------------------------------------------
void DCF_ARRAY_Clear(void)
{
    byte i;
    for (i=0; i<7; i++) DCF_ARRAY[i]=0;
}
//--------------------------------------------------------------------------
// Initialisation for DCF-Mode
void DCF_INIT(void)
{
    Port_DataDirBit(DCF_IN,0);    // Port D.7=input
    Port_WriteBit(DCF_IN,1);      // pull up on
    Port_DataDirBit(30,1);        // enable LED1
    Port_WriteBit(30,1);          // LED1 off
    DCF_ARRAY_Clear();
    DCF_MODE=0;                     //DCF disabled
}
//-------------------------------------------------------------------
// START DCF-Mode
void DCF_START(void)
{
    SEC_CNT=0;
    ARRAY_INDEX=0;
    DCF_ARRAY_Clear();
    DCF_PARITY=0;
    DCF_LIMIT_CNT=0;             // Abbruch wenn kein Signal vorhanden
    DCF_DATA=0;
    BIT_CNT=0;
    DCF_MODE=1;                  // DCF enabled
}
//-------------------------------------------------------------------
//********* DCF_MODE=1 Puls suchen *********************************
void DCF_PULS(void)
{
    if (DCF_MODE==1)
    {
        if (Port_ReadBit(DCF_IN)) SEC_CNT++;
        else SEC_CNT=0;

        if (SEC_CNT==5)
        {
            DCF_MODE++;               // Puls gefunden > Modewechsel
            SEC_CNT=0;
        }
    }
}
//
//********* DCF_MODE=2 Frameanfang suchen ***************************
// Synchronisation auf den Frameanfang (Pulsl├╝cke)
// St├Ârungen <20ms weden ignoriert
void DCF_SYNC(void)
{
    if (DCF_MODE==2)
    {
// Abbruch wenn nach 3 Minuten kein Frameanfang gefunden wurde
        DCF_LIMIT_CNT++;
        if (DCF_LIMIT_CNT>20000)   // > 3 Minuten
        {
            DCF_ARRAY[6]=0xFF;   // kein SYNC
            DCF_MODE=0;          // Limit erreicht
        }
// Minutensynchronisation: fehlender Bit-Puls
        if (Port_ReadBit(DCF_IN))
        {
            DCF_DATA++;
            if (DCF_DATA==5)    // 50ms Pulsbreite
            {
                // neuer Start
                SEC_CNT=0;
                DCF_DATA=0;
            }
        }
        else
        {                   // kein Puls vorhanden
            DCF_DATA=0;
        }
        SEC_CNT++;
        if (SEC_CNT==130)
        {                    // Minuten_SYNC gefunden
            DCF_MODE++;          // Modewechsel
            SEC_CNT=0;
            BIT_CNT=0;
            DATA_CNT=0;
            CNT8=0;
            Shift_CNT=0;
        };
    }
}

//---------------------------------------------------------------------------------
// BCD Kodierung zu Dezimal Wandlung
//
byte BCD2DEC(byte value)
{
    return((value>>4)*10+(value&0xf));  // oberes Nibble * 10 plus unteres Nibble
}

//---------------------------------------------------------------------------------
//******** DCF_MODE=3  Datenaufnahme *******************************
// Die seriellen Daten ab Minuten werden in DCF_ARRAY abgelegt
// ein Durchlauf dauert ca. 1ms@16MHz
void DCF_FRAME(void)
{
    if (DCF_MODE==3)
    {
        SEC_CNT++;
        if (Port_ReadBit(DCF_IN))
        {
            DATA_CNT++;                // Pulse z├Ąhlen f├╝r Datenauswertung
        }
// Datenauswertung --------------------------------------------------
        if (SEC_CNT==100)                          // 10ms Abtastung: 100x10ms=1s
        {
            // Bit eingelesen, Auswertung
            if (DATA_CNT>=15)
            {
                DCF_DATA=1;
                DCF_PARITY++;                      //increment parity counter
            }
            else
            {
                DCF_DATA=0;
            }
            DATA_CNT=0;
            SEC_CNT=0;                            // reset CNT_SEC
            BIT_CNT++;                            // ready for next Data Bit
//---------------------------------------------------------------------
// Datenaufnahme, Bit0 bis Bit21 ignorieren ---------------------------------
// Die Daten f├╝r Minuten, Stunden usw. werden getrennt in ein Byte im DCF_ARRAY
// abgelegt, z.B. Minuten in DCF_ARRAY[0]: Minuten_low Bit0..3, Minuten_high Bit4..6
//
// DCF_ARRAY[0] : Minuten
// DCF_ARRAY[1] : Stunden
// DCF_ARRAY[2] : Tag
// DCF_ARRAY[3] : Wochentag
// DCF_ARRAY[4] : Monat
// DCF_ARRAY[5] : Jahr
// DCF_ARRAY[6] : Error ( Synchronisation, Parity)
//-------------------------------------------------------------------------------
            if (BIT_CNT>=22)   // Start der Datenaufnahme ab Minuten
            {
                if (BIT_CNT==22)
                {
                    Shift_CNT=7;
                }  // Minuten
                if (BIT_CNT==30)
                {
                    Shift_CNT=6;
                }  // Stunden
                if (BIT_CNT==37)
                {
                    Shift_CNT=6;
                }  // Tag
                if (BIT_CNT==43)
                {
                    Shift_CNT=3;
                }  // Wochentag
                if (BIT_CNT==46)
                {
                    Shift_CNT=5;
                }  // Monat
                if (BIT_CNT==51)
                {
                    Shift_CNT=8;
                }  // Jahr
//---------   Daten bitweise an die richtige Position schieben
                if (Shift_CNT>0)
                {                  // DCF-Daten von links schieben
                    DCF_ARRAY[ARRAY_INDEX]=(DCF_ARRAY[ARRAY_INDEX]>>1)|(DCF_DATA<<7);
                    CNT8++;
                    Shift_CNT--;
                    if (Shift_CNT==0)   // Daten rechtsb├╝ndig schieben
                    {
                        for (CNT8=CNT8; CNT8<8; CNT8++)
                        {
                            DCF_ARRAY[ARRAY_INDEX]=(DCF_ARRAY[ARRAY_INDEX]>>1);
                        }
                        ARRAY_INDEX++;
                        CNT8=0;
                    }
                }
//---------- Byte vollst├Ąndig aufgenommen und im DCF_ARRAY gespeichert
//---------- Parity ├╝berpr├╝fen ( Minuten, Stunden, Rest )
                if (BIT_CNT==21)
                {
                    DCF_PARITY=0;                      // reset parity counter
                };
                if (BIT_CNT==29)
                {
                    if ((DCF_PARITY&1)==1)             // check parity
                    {
                        DCF_ARRAY[6]=1;                // Minuten Error
                    }
                    DCF_PARITY=0;                      // reset parity counter
                };
                if (BIT_CNT==36)
                {
                    if ((DCF_PARITY&1)==1)
                    {
                        DCF_ARRAY[6]=DCF_ARRAY[6]|2;   // Stunden Error
                    }
                    DCF_PARITY=0;                      // reset parity counter
                }
                if (BIT_CNT==59)                       // 59=3B Parity P3
                {
                    if ((DCF_PARITY&1)==1)
                    {
                        DCF_ARRAY[6]=DCF_ARRAY[6]|4;   // Final Parity Error
                    }
//------------   END of DCF-DATA-TRANSMISSION
                    DCF_MODE=0;                        // DCF finished
                    if (DCF_ARRAY[6]==0)             // DCF ok
                    {
                        Minute=BCD2DEC(DCF_ARRAY[0]);         // Uhrzeit ├╝bernehmen
                        Stunde=BCD2DEC(DCF_ARRAY[1]);
                        Tag=BCD2DEC(DCF_ARRAY[2]);
                        Monat=BCD2DEC(DCF_ARRAY[4]);
                        Jahr=BCD2DEC(DCF_ARRAY[5]);
                        Sekunde=0;
                        cnt1=0;
                    }
                    else
                    {
                        DCF_START();                 // neuer Versuch
                    }
                }
            }
        }  // END Datenaufnahme
    }   // END DCF_MODE=3
}
//-------------------------------------------------------------------------



    Antwort schreiben


Antworten: