Atmega328p/Arduino: uint64_t shl > 16 Bit geht nicht

[egon (Gast)]

Wie kann ich denn die Bits eines uint64_t > 15 setzen?

Alles über Bit 15 wird ignoriert:

uint64_t a =1;
  
  a |= (1 << 1);   //wird ignoriert
  a |= (1 << 14);  //das wird gesetzt
  a |= (1 << 15);  //das wird gesetzt
  a |= (1 << 16);  //das nicht
  a |= (1 << 31);  //das nicht
  for (int i = 63; i >= 0; i--) {
    if ( (a & (1<<i)) > 0) {
      Serial.print("1");
    }
    else {
      Serial.print("0");
    }
    if (i%4 == 0 ) {
      Serial.print(" ");
    }
  }

Ich habe auch schon

a|= ( (uint64_t)1 << 44);

probiert, geht auch nicht.

[egon (Gast)]

a |= (1 << 1);   //wird ignoriert

Wird nat. nicht ignoriert.

[Falk B. (falk)]

@egon (Gast)

>Wie kann ich denn die Bits eines uint64_t > 15 setzen?

Indem man es richtig macht (tm).

>Alles über Bit 15 wird ignoriert:

a |= (1LL << 16);

Das Problem heißt Integer Promotion.

[holger (Gast)]

>Ich habe auch schon
>
>a|= ( (uint64_t)1 << 44);
>
>probiert, geht auch nicht.

Wenn deine Ausgabe nicht richtig funktioniert kannst du das
gar nicht kontrollieren ob das geht oder nicht.

Hier solltest du mal ansetzen:

    if ( (a & ((uint64_t)1<<i)) > 0) {

[egon (Gast)]

Falk Brunner schrieb:
> @egon (Gast)
>
>>Wie kann ich denn die Bits eines uint64_t > 15 setzen?
> Indem man es richtig macht (tm).
>>Alles über Bit 15 wird ignoriert:
> a |= (1LL << 16);
> Das Problem heißt Integer Promotion.
Das ist exakt das selbe wie (uint64_t)1 << 16.... was ich schon 
probierte.

Das Problem war das noch in der Ausgabe zu berücksichtigen, wie holger 
schrieb. Jetzt geht es auch mit der Prefixtypkonversion, diese 
Schreibweise ist mir lieber weil auffälliger.

[Karl H. (kbuchegg)]

egon schrieb:

> Das Problem war das noch in der Ausgabe zu berücksichtigen, wie holger
> schrieb. Jetzt geht es auch mit der Prefixtypkonversion, diese
> Schreibweise ist mir lieber weil auffälliger.


Noch lieber sollte dir sein

  uint64t mask = 0x80000000;

  for (uint8_t i = 0; i < 64; i++) {
    if ( a & mask ) {
      Serial.print("1");
    }
    else {
      Serial.print("0");
    }
    if (i%4 == 0 ) {
      Serial.print(" ");
    }
    mask >>= 1;
  }

die Operation

    a << b

willst du mit einem variablen b auf einem AVR nicht haben, wenn du sie 
vermeiden kannst. Die artet für den AVR nämlich in Schwerarbeit aus.

Noch besser wäre ein Schema, bei dem du dir Funktionen baust, die 
aufeinander aufbauen, und letzten Endes einen uint64_t in Form von 8 
Bytes ausgeben.

void binaryNibble( uint8_t nibble )
{
  if( nibble & 0x08 ) Serial.print("1"); else Serial.print("0");
  if( nibble & 0x04 ) Serial.print("1"); else Serial.print("0");
  if( nibble & 0x02 ) Serial.print("1"); else Serial.print("0");
  if( nibble & 0x01 ) Serial.print("1"); else Serial.print("0");
}

void binaryByte( uint8_t byte )
{
  binaryNibble( byte >> 4 );
  Serial.print(" ");
  binaryNibble( byte );
}

void binaryWord( uint16_t word )
{
  binaryByte( word >> 8 );
  Serial.print( " " );
  binaryByte( word );
}

void binaryDWord( uint32_t dWord )
{
  binaryWord( dWord >> 16 );
  Serial.print( " " );
  binaryWord( dWord );
}

void binaryQWord( uint64_t qWord )
{
  binaryDWord( qQWord >> 32 );
  Serial.print( " " );
  binaryDWord( qWord );
}

so entsteht automatisch ein Satz von Funktionen, der für alle unsigned 
int Datentypen die richtige Funktion bereit hält und zur Laufzeit mit 
wenigen Schiebeoperationen auskommt, die dann auch noch alle vom 
Compiler wegoptimiert werden können, indem er einfach immer nur den 
relevanten 'Auszug' aus den Werten an die tiefer liegende Funktion 
weitergibt.
(Die binaryNibble könnte man noch eleganter schreiben, ich belass es 
aber erst mal bei dieser Version)

[egon (Gast)]

Karl Heinz schrieb:

> (Die binaryNibble könnte man noch eleganter schreiben, ich belass es
> aber erst mal bei dieser Version)
Aha interessant, dachte mir schon dass 64Bit-Typen auf so einen kleinen 
Ding nicht 'echt' vorhanden sind und das durch Compiler"magie" 
hingebogen wird.

Macht man das dann auch so wenn man beliebig lange Typen haben will, 
z.B. 1024 Bit und darauf herumshiften will? Nimmt man dann ein entspr. 
langes uint8_t array und implementiert entspechende shl(), shr() die 
unter der Haube die "Drecksarbeit" machen?