2xBytes - Bitweise alternierend zusammenfügen

[superb (Gast)]

Hallo zusammen,

hat jemand einen Tipp wie zwei Bytes bitweise-alternierend 
zusammengefügt werden können.

first Byte:  [a b c d e f g h]
second Byte: [1 2 3 4 5 6 7 8]

->   Word(16Bit): [a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8]

Danke.

[Faulpelz (Gast)]

Hausaufgabe?
Oder wes ist der Zweck des Ganzen?

[Ben S. (bensch123)]

uint16_t u16Result = 0;
uint8_t u8A = 0b10101010;
uint8_t u8B = 0b01010101;

for(uint8_t i = 0; i < 8; i++){
  if(u8A & (1<<i)) u16Result  |= (1<<(i*2));
  if(u8B & (1<<i)) u16Result  |= (1<<(i*2+1));
}

[vllt so? (Gast)]

for i= 0 bis 7

Word(16Bit) = Word(16Bit) | ((firstByte>>(7-i))&1)
Word(16Bit) = Word(16Bit)<<1

Word(16Bit) = Word(16Bit) | ((secondByte>>(7-i))&1)
Word(16Bit) = Word(16Bit)<<1

EndFor

[Faulpelz (Gast)]

So als Lösungsansatz (mein Assembler ist etwas eingestaubt).
Eine Schiebeoperation sorgt dafür, dass das rausgeschobene Bit im Carry 
landet. Dann kann man ein "AddWithCarry" mit 0 machen, und das Ergebnis 
entsprechend weiterschieben.
Das Ganze in einer kleinen Schleife.

[Ben S. (bensch123)]

vllt so? schrieb:
> for i= 0 bis 7
>
> Word(16Bit) = Word(16Bit) | ((firstByte>>(7-i))&1)
> Word(16Bit) = Word(16Bit)<<1
>
> Word(16Bit) = Word(16Bit) | ((secondByte>>(7-i))&1)
> Word(16Bit) = Word(16Bit)<<1
>
> EndFor

uint16_t u16Result = 0;
uint8_t u8A = 0b10101010;
uint8_t u8B = 0b01010101;

for(uint8_t i = 0; i < 8; i++){
  u16Result |= u8A & 1;
  u8A >> 1;
  u16Result << 1;

  u16Result |= u8B & 1;
  u8B >> 1;
  u16Result << 1;
}

[Theor (Gast)]

result = fb[7] sb[7] fb[6] sb[6] fb[5] sb[5] fb[4] sb[4] fb[3] sb[3] 
fb[2] sb[2] fb[1] sb[1] fb[0] sb[0];

[] ist der Bit-Indizierungsoperator.

[Ben S. (bensch123)]

Ben S. schrieb:
> uint16_t u16Result = 0;
> uint8_t u8A = 0b10101010;
> uint8_t u8B = 0b01010101;
>
> for(uint8_t i = 0; i < 8; i++){
>   u16Result |= u8A & 1;
>   u8A >> 1;
>   u16Result << 1;
>
>   u16Result |= u8B & 1;
>   u8B >> 1;
>   u16Result << 1;
> }

Fehler, dies getestet:

uint16_t combine (uint8_t u8A, uint8_t u8B) {
  uint16_t u16Result = 0;

  for (uint8_t i = 0; i < 8; i++) {
    u16Result |= u8A & 1;
    u8A >>= 1;
    u16Result <<= 1;

    u16Result |= u8B & 1;
    u8B >>= 1;
    u16Result <<= 1;
  }

  return u16Result;
}

[superb (Gast)]

Alles klar.
Damit kann ich etwas anfangen.

Mir ging es primär um die Logik.
Programmieren müsste ich das in SCL (SPS).

Danke.

[Caligulaminus (Gast)]

Ohne Schleife:

int16_t shuffle16(std::uint8_t a, std::uint8_t b)
{
  uint16_t val = static_cast<uint16_t>(a) << 8 | b;
  uint16_t mask;
  mask = (val ^ (val >> 4)) & 0x00f0;
  val = val ^ mask ^ (mask << 4);
  mask = (val ^ (val >> 2)) & 0x0c0c;
  val = val ^ mask ^ (mask << 2);
  mask = (val ^ (val >> 1)) & 0x2222;
  val = val ^ mask ^ (mask << 1);

  return val;
}

[Ben S. (bensch123)]

Caligulaminus schrieb:
> Ohne Schleife:

Auch schön, jedoch sollte man manchmal eine lesbare Version vorziehen. 
Zumindest finde ich deine Lösung nicht intuitiv - ist aber nur meine 
Meinung.

[voll der google checker (Gast)]

Ben S. schrieb:
> uint16_t combine (uint8_t u8A, uint8_t u8B) {
>   uint16_t u16Result = 0;
>
>   for (uint8_t i = 0; i < 8; i++) {
>     u16Result |= u8A & 1;
>     u8A >>= 1;
>     u16Result <<= 1;
>
>     u16Result |= u8B & 1;
>     u8B >>= 1;
>     u16Result <<= 1;
>   }
>
>   return u16Result;
> }

Die Schieberei am Ende liefert falsches Ergebnis.

   for (uint8_t i = 0; i < 8; i++) {                                    
      u16Result <<= 1;                                                  
      u16Result |= u8A & 1;                                             
      u8A >>= 1;  
                                                      
      u16Result <<= 1;                                                                                                           
      u16Result |= u8B & 1;                                             
      u8B >>= 1;                                                        
   }

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

In Assembler würde ich das angesichts heutiger Prozessoren
"Speedcode-Style" schreiben, also 32 einfache Bitshifts
über Carry, fertig. Vielleicht nicht ganz so elegant wie mit
einer Schleife, aber moderne Prozessoren mit ihren großen
Caches und Optimierungen dürften das in wenigen Takten
erledigt haben und die paar Byte mehr Speicherplatzbedarf
fallen heute nicht mehr auf.