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