bits werden nicht vollständig in struct eingelesen

Hallo,

ich hab jetzt meinen DCF-Decoder so weit erweitert, dass er nun auch das Datum dekodieren kann. Zumindest sollte er das, aber komischerweise werden die empfangenen Bits fürs Datum nicht mehr in die DCF-struct eingelesen:

Code:

---


struct DCF{
        uint64_t startbit        :1;

        uint64_t m1        :1;        //minute
        uint64_t m2        :1;
        uint64_t m4        :1;
        uint64_t m8        :1;
        uint64_t m10        :1;
        uint64_t m20        :1;
        uint64_t m40        :1;
        uint64_t Pm        :1;        //parity        of minute

        uint64_t h1        :1;        //hour
        uint64_t h2        :1;
        uint64_t h4        :1;
        uint64_t h8        :1;
        uint64_t h10        :1;
        uint64_t h20        :1;
        uint64_t Ph        :1;        //parity        of hour

        uint64_t d1        :1;        //day
        uint64_t d2        :1;
        uint64_t d4        :1;
        uint64_t d8        :1;
        uint64_t d10        :1;
        uint64_t d20        :1;
       
        uint64_t dw1        :1;
        uint64_t dw2        :1;
        uint64_t dw4        :1;

        uint64_t M1        :1;        //month
        uint64_t M2        :1;
        uint64_t M4        :1;
        uint64_t M8        :1;
        uint64_t M10        :1;

        uint64_t y1        :1;        //year
        uint64_t y2        :1;
        uint64_t y4        :1;
        uint64_t y8        :1;
        uint64_t y10        :1;
        uint64_t y20        :1;
        uint64_t y40        :1;
        uint64_t y80        :1;
        uint64_t        Pd        :1;        //parity of date
};

volatile uint8_t bitcounter;    //zählt empfangene Bits
volatile uint64_t bits;            //64 Bit lang, 59 werden benötigt
struct DCF* dcf;                //bits sollen hier eingetragen werden

---

Code:

---

if(ms>=750 && ms<970)        //1
        {
                if(bitcounter>=20)                        //ersten 20 bits werden übersprungen
                        bits|=(1<<(bitcounter-20));  //Zeitbits werden gespeichert

                bitcounter+=1;
                send(" 1 ");
                PORTD|=(1<<PD6);
                return;
        }

        if(ms>=970 && ms<1300)        //0
        {
                if(bitcounter>=20)
                        bits&=~(1<<(bitcounter-20));

                bitcounter+=1;
                send(" 0 ");
                PORTD&=~(1<<PD6);
                return;
        }

        if(ms>=1300)        //Sekundenmarke
        {
                if(bitcounter>=20)
                        bits&=~(1<<(bitcounter-20));

                dcf=(struct DCF*)(uint64_t)&bits;      //Bits werden in struct übernommen -> geht anscheinend nicht!
                decode(bitcounter);        //dcf wird dann dekodiert
                bitcounter=0;                //bitzähler wird resettet
                send(" 0 START: ");
                startDCF();                //neustart
                return;
        }

---

Wenn ich mir jetzt die Datumbits in dcf ausgeben lasse, stehen da nur Nullen da, obwohl auch Einsen empfangen wurden, irgendwie werden die Bits nicht übernommen. Weiß einer von euch warum?

Gruß
cesupa[/code]

Wieso hast du oben mit
struct DCF* dcf;
einen Zeiger auf die Struktur erstellt? Ist wohl ein Fehler ^^

Hab auch schon DCF-Empfang in C geschrieben, aber anderen Ansatz gewählt ;-)

rechnest du etwa mit long long??? Da hat jemand Flash wie Heu... ;-)

Ich lese es einfach mal aus der Kristallkugel, weil das geggesnippt ist und nicht zu ersehen. Falls es so ist, dann muss es heissen

Code:

---

bits |= 1ULL << ...

---

etc.

ausserdem hast du da ein gar wüstes Rumgecaste drinne,was zudem noch falsch ist (dcf wird die Adresse von bits);

Code:

---

dcf=(struct DCF*)(uint64_t)&bits

---

Wieder mit der Kristallkugel...

Code:

---

dcf = * ((struct DCF*) &bits);

---

Klarer wäre hier ne Union

Code:

---

typedef union
{
  {
      unsigned int start :1;
      unsigned int minute :7; 
      unsigned int minute_parity:1; 
  };
  uint64_t bits;
} dcf_t;

dcf_t dcf;

...
  dcf.bits |= ...
  printf ("%d\n", dcf.minute);

---

Falls es kein GNU-C sein soll sondern nur ANSI-C, anstatt der anonymen inneren Struktur einfach ne benamte nehmen.

Hallo,

ich hab die struct jetzt in eine union gepackt, wie du gesagt hast:

Code:

---


typedef union
{
uint64_t dcfsig;
        struct {
                uint32_t stuff        :20;
                unsigned int startbit        :1;

                unsigned int minutes        :7;        //minute
                unsigned int Pm                :1;        //parity        of minute

                unsigned int hours        :6;        //hour
                unsigned int Ph                :1;        //parity        of hour

                unsigned int days        :6;        //day
                unsigned int weekdays        :3;
                unsigned int months        :5;        //month
                unsigned int years        :8;        //year       
                unsigned int        Pd        :1;        //parity of date
        };

}dcf_t;

//...
volatile dcf_t bits;
//...

---

In bits.dcfsig lese ich dann die Bits ein, die ja dann eigentlich auf die struct gelegt werden:

Code:

---

if(ms>=750 && ms<997)        //1
        {
               
                bits.dcfsig|=(1<<bitcounter);

                bitcounter+=1;
                send(" 1 ");
                PORTD|=(1<<PD6);
                return;
        }

        if(ms>=997 && ms<1300)        //0
        {
               
                        bits.dcfsig&=~(1<<bitcounter);

                bitcounter+=1;
                send(" 0 ");
                PORTD&=~(1<<PD6);
                return;
        }

        if(ms>=1300)        //0
        {
               
                        bits.dcfsig&=~(1<<bitcounter);

                //dcf=(struct DCF*)(uint64_t)&bits;
                decode(bitcounter);
                bitcounter=0;
                send(" 0 START: ");
                startDCF();
                return;
        }

---

Wenn ich mir dann aber z.B. dcf.minutes ausgeben lassen möchte, bekomme ich den Wert 127, was ja einem 7-Bitfeld entspricht, dessen Bits alle auf 1 sind, aber müsste da jetzt nicht eine Zahl rauskommen, deren Binärcoe, dem der empfangenen Minutenbist entspricht???

Gruß
cesupa