Verständnis bitweise Operationen - Verschiebung und UND

Question

uint8_t payload[] = { 0, 0 }; 
pin5 = analogRead(A0); 
payload[0] = pin5 >> 8 & 0xff; 
payload[1] = pin5 & 0xff; 

Dies ist Code aus der Bibliothek XBee von andrewrapp auf GitHub veröffentlicht. Ich habe mich gefragt, wie die bitweise Operation funktioniert. also nehmen wir an, Pin 5 bekommt einen analogen Wert von 256, der als Partikel Photon Board kommt in einem 12bit Format Text als 000100000000. Also bekommt Nutzlast [0] die letzten acht Bits dh 00000000, oder bekommt es Wert nach dem Verschieben dh 00000001? Wie wird dann der Wert in Payload [1]?

Ich möchte einen 4-Bit-Code hinzufügen, der eine Bitmaske zu den ersten vier Bits im Array gefolgt von den Datenbits verwendet. Kann ich & Nutzlast [1] mit einer 0X1 zur Nutzlast [1] dafür?

Answer 1

Der Code in Ihrem Beispiel Umkehrer den Inhalt von pin5 ‚s zwei Bytes in payload Array: das höchstwertige Byte in payload[0] platziert und das niedrigstwertige Byte in payload[1] platziert.

Wenn zum Beispiel pin50x0A63, dann würde payload0x63 enthalten, 0x0A.

Wenn pin5 einen 12-Bit-Wert hat, können Sie seine vier höchstwertigen Bits verwenden, um einen eigenen Vier-Bit-Wert zu speichern. Um sicherzustellen, werden die oberen Bits auf Null gesetzt, verwenden 0x0F Maske statt 0xFF:

payload[0] = pin5 >> 8 & 0x0f; 
//      ^

Jetzt können Sie Ihre Daten in die oberen vier Bits mit | Operator bewegen:

payload[0] |= myFourBits << 4; 

Answer 2

Sie wollen also zu verstehen, was die angegebenen Operationen tun. Werfen wir einen Blick haben, wenn wir dies klären können, indem die pin5 Variable untersuchen und sie in zwei Teile unterteilt:

pin5    000100000000 
        MMMMLLLLLLLL 

M = 4 höchstwertigen Bits, L = 8 Least Significant Bits

payload[0] nimmt das Ergebnis einige Operationen auf pin5:

pin5    000100000000 
>> 8    000000000001 Shifts all bits 8 positions to the right 
        00000000MMMM and fills the left part with zeroes 

so haben Sie die ursprünglich führenden 4 Bits nun rechtsbündig-, auf dem eine zusätzliche Operation durchgeführt wird:

    000000000001 
& 0xFF   000011111111 Anding with FF 
        000000000001 

Rechtsverschiebung einer 12-Bit-Variablen um 8 Positionen ergibt 4 signifikante Positionen; die führenden 8 Bits sind immer 0. 0xFF ist binär 11111111, d.h. repräsentiert 8 gesetzte Bits. Was also hier gemacht wird, ist, die 4 niedrigstwertigen Bits mit 8 niedrigstwertigen Bits zu versehen, um sicherzustellen, dass die 4 höchstwertigen Bits gelöscht werden.

    00000000xxxx Potentially set bits (you have 0001) 
        000011111111 & 0xFF 
        00000000xxxx Result 
         0000xxxx Storing in 8-bits variable 
payload[0] =   00000001 in your case 

In diesem Fall wird der And ing Betrieb ist nicht sinnvoll und eine komplette Zeitverschwendung, weil And jede Variable mit 0xFF ing hat nie seinen 8 niedrigstwertigen Bits in irgendeiner Weise ändern, und da die 4 höchstwertigen Bits werden sowieso nie gesetzt, es gibt einfach keinen Sinn in dieser Operation.

(Technisch gesehen, weil die Quelle ein 12-Bit-Variable ist (vermutlich ist es ein 16-Bit-Variable aber mit nur 12 signifikant (relevant) binären Ziffern), 0x0F für den And ing Maske ausgereicht hätte. Kannst du sehen, ?. warum Aber selbst würde dies einfach ein verschwendeter CPU-Zyklus sein)

payload[1] nimmt auch das Ergebnis einer Operation auf pin5:

pin5    MMMMLLLLLLLL potentially set bits 
& 0xFF   000011111111 mask to keep LLLLLLLL only 
        0000LLLLLLLL result (you have 00000000) 
         xxxxxxxx Storing in 8-bits variable 
payload[1] =   00000000 in your case 

In diesem Fall Anding mit 11111111 macht Sinn, weil es verwirft MMMM, wh Ich in Ihrem Fall ist 0001.

Also, alles in allem, Ihr Wert

pin5    000100000000 
        MMMMLLLLLLLL 

ist so aufgeteilt, dass payload[0] enthält MMMM (0001 = dezimal 1) und payload[1] enthält LLLLLLLL (00000000 = dezimal 0) gewonnen.

Wenn der Eingang war

pin5    101110010001 
        MMMMLLLLLLLL 

stattdessen würden Sie in payload[0] finden: 1011 (dezimal 8 + 2 + 1 = 11) und in payload[1]: 10010001 (dezimal 128 + 16 + 1 = 145) .

Sie dieses Ergebnis als Dezimalzahl interpretieren würden 11 * 256 + 145 = 2961, das gleiche Ergebnis erhalten Sie, wenn Sie die ursprünglichen 101.110.010.001 von binärer in Dezimal-Umwandlung, beispielsweise unter Verwendung von calc.exe in Programmiermodus (Alt+3), wenn Sie Windows verwenden .

Ihre ursprünglichen Daten werden wie erwartet als 1 * 256 + 0 = 256 interpretiert.