bits werden nicht vollständig in struct eingelesen

[cesupa]

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:




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





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]

[geronet]

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 ;-)

[SprinterSB]

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



bits |= 1ULL << ...

etc.

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



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


Wieder mit der Kristallkugel...



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


Klarer wäre hier ne Union


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.

[cesupa]

Hallo,

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




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:



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