Bit shift misteriös

ich muss einen Wert um 24 bit verschieben, d.h. im Prinzip multiplizieren

Wert ist als unsigned long also 32 bit deklariert
würde als denken

wert = 0x5E;
wert = wert << 24;

heraus kommt leider 0x00
schreibe ich jedoch

wert = 0x5E;
wert = wert << 8;
wert = wert << 8;
wert = wert << 8;

erhalte ich wie gewünscht 0x5E000000

Alles shift Werte > 8 funktionieren nicht, obwohl in der Beschreibung von Bitshift Beispiele mit >> 16 stehen.
OK für mich ist das mal primär gelöst, aber schön ist das nicht.
Gruß
Rainer

Hallo Rainer,
Leider zeigst Du wieder nur ein Rudiment, mit dem man nichts anfangen kann. Auch sagst Du nicht, welchen Arduino du einsetzt.
Wenn wert richtig deklariert ist, funktioniert das bei mir. (Auf einem Micro )

uint32_t wert;
void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  while(!Serial);
  wert = 0x5E;
  wert = wert << 24;
  Serial.println(wert,HEX);
}

void loop() {
  // put your main code here, to run repeatedly:

}

ergibt

5E000000

Hallo Franz Peter,

hier der ganze code, mit mehrfachen shift, ja nicht sehr elegant

                         // if is Clock else ignore or NACK
                        unsigned long unix_time;
                        unsigned long tmp_time;
                        Serial.println(recBuf[M_Data],HEX);
                        tmp_time = recBuf[M_Data] << 8;
                        tmp_time = tmp_time << 8;
                        tmp_time = tmp_time << 8;
                        unix_time = tmp_time;
                        Serial.println(unix_time,HEX);
                        
                        tmp_time = recBuf[M_Data+1] << 8;
                        tmp_time = tmp_time << 8;
                        Serial.println(tmp_time,HEX);
                        unix_time = unix_time + tmp_time;
                        Serial.println(unix_time,HEX);
                        
                        tmp_time = recBuf[M_Data+2] << 8;
                        Serial.println(tmp_time,HEX);
                        
                        unix_time = unix_time + tmp_time;
                        Serial.println(unix_time,HEX);
                        unix_time = unix_time + recBuf[M_Data+3];
                        Serial.println(unix_time,HEX);

Der Sinn dahinter ich bekomme unixtime 32bit aufgeteilt auf 4 Byte die ich wieder in einen 32 bit Wert zusammensetze. recBuf ist als unsigned char definiert, M_Data ist Offset in recBuf, in diesem Fall 4
Ich würde doch mal denken unsigned long ist/sollte das selbe sein wie uint32_t.
Ferner erzeugt ein shift um 8 von 0xF1 nicht das erwartete 0xF100 sondern 0xFFFFF100 also eine negative Zahl, wieso habe ich dann unsingned, oder sollte ich doch besser alles mit unit??_t deklarieren.
Danke für die schnelle Antwort.
Gruß
Rainer

Der ganze Code ist es offensichtlich nicht.

Hier ist z.B. ein Problem

tmp_time = recBuf[M_Data] << 8;

Da wird mit dem Typ gerechnet, den ein Element von recBuf hat, wahrscheinlich char oder unsigned char. Danach erfolgt dann erst die Zuweisung an tmp_time und ggf. Erweiterung auf den größeren Typ.

Das kling logisch, Danke

Ferner erzeugt ein shift um 8 von 0xF1 nicht das erwartete 0xF100 sondern 0xFFFFF100 also eine negative Zahl, wieso habe ich dann unsingned, oder sollte ich doch besser alles mit unit??_t deklarieren.

Leider hast du in deinem C++ Buch die Seiten zur automatischen Konvertierung (implizit Cast) überschlagen, oder nur nicht verstanden.
Also nochmal lesen.

Du denkst unsauber.
Zeigst kein testbares Beispiel.

So wird das nix.

Einfach nur Behauptungen aufstellen und wirre Vermutungen generieren, ist irrelevant.
Damit verwirrst du dich nur selber.