Bits maskieren und dann verschieben

Hamstaaa

@hustbaer sagte in Bits maskieren und dann verschieben:

uint64_t data16X = 0; // 16?

Ja, hat seinen Grund
Hier soll sozusagen ein uint16_t aus einem uint64_t "extrahiert" werden. Sinn ist es, etwas zu überprüfen.

uint64_t dataX = 0b101010; // 00101010 ist eine oktale Konstante und sicher nicht dezimal 42

sorry 0b101010 war natürlich gemeint

dataX >>= 1; // Erstes zu kopierendes bit auf Position 0 bringen
for (int i = 0; i < 32 ; i++)
{
    data16X <<= 1; // Platz machen für das neue Bit im Ergebnis
    data16X |= dataX & 1; // Bit an Position 0 kopieren
    dataX >>= 2; // Nächstes zu kopierendes Bit auf Position 0 bringen
}

Danke, das werde ich gleich einmal ausprobieren!

Jedoch tun sich grade neue Probleme auf, da mein uint64_t aus dem extrahiert werden soll anscheinend in der falschen Richtung gesendet wird

Probleme über Probleme

DocShoe

Warum kein std::bitset?

#include <bitset>
#include <climits>

using namespace std;

unsigned int condense_bits( unsigned int input )
{
   // abhängig davon, welche der Bits aus den jeweils zwei Bits relevant sind kann Mask 0x01, 0x02 oder 0x03 sein
   static unsigned int const Mask = 0x02;

   bitset<16> bs;
   for( size_t i = 0; i < sizeof( input ) * CHAR_BIT; i+= 2 )
   { 
      bs[i/2] = (input >> i) & Mask;
   }
   return bs.to_ulong();
}

int main()
{
   unsigned int v = condense_bits( 42 );
}

Edit:
Wenn du einen uint16_t aus einem uint64_t extrahieren willst dann passt das aber nicht in einen uint16_t.

Schlangenmensch

@Hamstaaa sagte in Bits maskieren und dann verschieben:

Jedoch tun sich grade neue Probleme auf, da mein uint64_t aus dem extrahiert werden soll anscheinend in der falschen Richtung gesendet wird

Das klingt fast nach Byteorder (Endianness), grade wenn's ums versenden und empfangen via Netzwerk geht. Je nach verwendetem System gib es Funktionen die von Host zu Network Byteorder oder umgekehrt konvertieren.

Hamstaaa

@DocShoe

std::bitset habe ich auch in Verwendung.

void printbits(uint64_t number)
{
    uint64_t chXmask64 = 0xAAAAAAAAAAAAAAAA;
    uint64_t chYmask64 = 0x5555555555555555;
    uint64_t dataX = number & chXmask64;
    uint64_t dataY = number & chYmask64;
        
    std::bitset<40>binX (dataX);
    std::bitset<40>binY (dataY);
    printf("\nX BINARY: "); std::cout << binX << "          X DECIMAL: " << dataX;
    printf("\nY BINARY: "); std::cout << binY << "          Y DECIMAL: " << dataY;
}

Ich lasse mir damit den Binärcode von dem jeweiligen Kanal ausgeben.

void magic(uint32_t a, uint32_t b)
{
  
uint64_t result64=0;
uint32_t mask = 1u << 31u;

    for (int i=0; i<32; i++) 
    {
      result64 <<= 2;
      result64 |= (!!(a & mask) << 1);
      result64 |= !!(b & mask);
      mask >>= 1;
    }
printbits(result64);
}

Wie wäre denn sonst der Code für die andere Byteorder?

hustbaer

Ohne dass jetzt unbedingt ein 1:1 Match zu einem Problem auf der Seite bestehen würde...
Ein Link der bei dem Thema einfach nicht fehlen darf: https://graphics.stanford.edu/~seander/bithacks.html

Hamstaaa

@hustbaer

Ist schon unter den Lesezeichen gespeichert

Wutz

@hustbaer sagte in Bits maskieren und dann verschieben:

uint64_t dataX = 0b101010;

0b ist kein Standard, nur GCC Extension.

Bashar

@Wutz sagte in Bits maskieren und dann verschieben:

0b ist kein Standard, nur GCC Extension.

Da bist du wohl nicht ganz up-to-date.

hustbaer

@Wutz
Das is C++14
https://en.cppreference.com/w/cpp/language/integer_literal

Wutz

@hustbaer
C++ interessiert mich nicht, schon gar nicht werde ich diesem quasijährlichen Standardupdatequatsch für essenzielle Basics hinterherlaufen.

Hamstaaa

Bitte liebe Community,

Ihr kennt ja nun meine Codeschnipsel.

Ohne noch lange um den heißen Brei zu schreiben, ich komme nicht wirklich weiter.

Ich möchte der folgenden Funktion 2 uint32_t's geben, die diese dann in einen uint64_t umwandelt, der folgendem Muster entspricht: abababababababab.........

void magic(uint32_t a, uint32_t b)
{
  
uint64_t result64=0;
uint32_t mask = 1u << 31u;

    for (int i=0; i<32; i++) 
    {
      result64 <<= 2;
      result64 |= (!!(a & mask) << 1);
      result64 |= !!(b & mask);
      mask >>= 1;
    }
}

Das funktioniert auch gut, jedoch kommen die Daten irgendwie in der falschen Reihenfolge an. Die debug Ausgabe ist auch erst mal Nebensache

Ich benötige für jeden der beiden Werte folgende Bitreihenfolge bedenke: <C2><C1><C0> ist immer 0 0 1; ist ein Paritätsbit. Das errechne ich.

<P><C2><C1><C0><D15><D14><D13><D12><D11><D10><D9><D8><D7><D6><D5><D4><D3><D2><D1><D0>

Momentan bekomme ich den folgenden String zusammen:

<D0><D1><D2><D3><D4><D5><D6><D7><D8><D9><D10><D11><D12><D13><D14><D15>

Kann ich die ganze Sache jetzt eleganter lösen als <C2><C1> und <C0> hinter <D15> zu ""klemmen" und den gesamten String bei jedem Sendevorgang umzudrehen?

Ich denke doch das etwas zu CPU intensiv ist auf meinem kleinen ESP32

Bitte erbarmt euch meiner

Hamstaaa

Dieser Beitrag wurde gelöscht!

@Wutz sagte in Bits maskieren und dann verschieben:

C++ interessiert mich nicht,

Weswegen du dich in C++ (alle ISO-Standards) äusserst. Is klar ...

It0101

@Hamstaaa sagte in Bits maskieren und dann verschieben:

Ich möchte der folgenden Funktion 2 uint32_t's geben, die diese dann in einen uint64_t umwandelt, der folgendem Muster entspricht: abababababababab.........

Also in deinem Eingangspost steht das so nicht drin...

hustbaer

@Wutz sagte in Bits maskieren und dann verschieben:

@hustbaer
C++ interessiert mich nicht, schon gar nicht werde ich diesem quasijährlichen Standardupdatequatsch für essenzielle Basics hinterherlaufen.

Das ist OK. Nur dann halt bitte den Rand anstatt falsche "Korrekturen" oder Anmerkungen zum Thema was Standard und was eine GCC Extension ist zu machen.

hustbaer

@Hamstaaa sagte in Bits maskieren und dann verschieben:

Ich möchte der folgenden Funktion 2 uint32_t's geben, die diese dann in einen uint64_t umwandelt, der folgendem Muster entspricht: abababababababab.........

https://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
Das von 2x16->32 auf 2x32->64 aufzublasen sollte denke ich nicht zu schwer sein.

Caligulaminus

@Hamstaaa sagte in Bits maskieren und dann verschieben:

Ich möchte der folgenden Funktion 2 uint32_t's geben, die diese dann in einen uint64_t umwandelt, der folgendem Muster entspricht: abababababababab.........

Das hatten wir doch hier schon mal.

Hamstaaa

@Caligulaminus sagte in Bits maskieren und dann verschieben:

@Hamstaaa sagte in Bits maskieren und dann verschieben:

Ich möchte der folgenden Funktion 2 uint32_t's geben, die diese dann in einen uint64_t umwandelt, der folgendem Muster entspricht: abababababababab.........

Das hatten wir doch hier schon mal.

DAS ist ja auch erledigt....

Hamstaaa

@hustbaer
@Caligulaminus
@It0101

Bitte.

Es geht darum die Reihenfolge des entstandenen uint64_t zu ändern, die Umwandlung/Übertragung des Strings KLAPPT SUPER!!!

Der untere Abschnitt meines Postes ist wichtig.

@hamstaaa Sagte:

Das funktioniert auch gut, jedoch kommen die Daten irgendwie in der falschen Reihenfolge an. Die debug Ausgabe ist auch erst mal Nebensache

Ich benötige für jeden der beiden Werte folgende Bitreihenfolge bedenke: <C2><C1><C0> ist immer 0 0 1; ist ein Paritätsbit. Das errechne ich.

<C2><C1><C0><D15><D14><D13><D12><D11><D10><D9><D8><D7><D6><D5><D4><D3><D2><D1><D0>
Momentan bekomme ich den folgenden String zusammen:

<D0><D1><D2><D3><D4><D5><D6><D7><D8><D9><D10><D11><D12><D13><D14><D15>
Kann ich die ganze Sache jetzt eleganter lösen als <C2><C1> und <C0> hinter <D15> zu ""klemmen" und den gesamten String bei jedem Sendevorgang umzudrehen?

hustbaer

Freund @Hamstaaa,
dann mach mal hübsch selber.

lol