-
        

Ergebnis 1 bis 4 von 4

Thema: bits werden nicht vollständig in struct eingelesen

  1. #1
    Benutzer Stammmitglied
    Registriert seit
    01.07.2005
    Beiträge
    64

    bits werden nicht vollständig in struct eingelesen

    Anzeige

    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]

  2. #2
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    01.01.2007
    Beiträge
    134
    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

  3. #3
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801
    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.
    Disclaimer: none. Sue me.

  4. #4
    Benutzer Stammmitglied
    Registriert seit
    01.07.2005
    Beiträge
    64
    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

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •