Déplacement d’octets et valeurs restantes converties en int (intéressé par le complément à deux)

Pourquoi le code que vous voyez ci-dessous donne-t-il ces résultats?

void loop() { byte test = 00000101; Serial.print("The byte test is: "); Serial.println(test); int x = (int)test; int y = (int)test<<8; Serial.print("The int x is: "); Serial.println(x); Serial.print("The int shifted y is: "); Serial.println(y); byte tost = 10000001; int z = test + tost; Serial.print("The int z is: "); Serial.println(z); delay(1000); } 

Résultats :

Le test d’octet est: 65

L’int x est: 65

L’intersport y est: 16640

L’int z est: 194

Tandis que si je change le test en 00000001, il fonctionne très bien:

Code modifié:

 void loop() { byte test = 00000001; Serial.print("The byte test is: "); Serial.println(test); int x = (int)test; int y = (int)test<<8; Serial.print("The int x is: "); Serial.println(x); Serial.print("The int shifted y is: "); Serial.println(y); byte tost = 10000001; int z = test + tost; Serial.print("The int z is: "); Serial.println(z); delay(1000); } 

Résultats:

 The byte test is: 1 The int x is: 1 The int shifted y is: 256 The int z is: 130 

Mon problème est que j’ai deux octets que je veux lire à partir de registres de données d’un accéléromètre. La valeur est stockée dans le complément à deux, donc je voulais vérifier car wire.read renvoie un octet que certaines personnes disent qui est signé et d’autres non signés si je détruis les valeurs, car je dois effectuer des décalages.

Je voulais donc vérifier si j’avais un octet et essayer de le déplacer et de le stocker dans un int, quelles valeurs puis-je obtenir et si je peux tester si je peux stocker des valeurs d’octets signés dans un tableau d’octets.

La réponse ci-dessus est correcte car Alexy Frunze a déclaré que le nombre commençant par 0 est octal.

 000000101 is 65 not 5 65 << 8 =16640 10000001 in decimal is 129 129+65 = 194 

Ce n’est pas parce que vous écrivez un nombre qui a l’air “binary” qu’il comporte beaucoup de 1 et de 0 et qu’il a 8 chiffres de large, ce qui en fait un littéral binary comme par magie. Comment vous attendriez-vous:

 byte x = 100; 

et

 byte x = 100; 

savoir que la valeur est supposée être 100 10 (un centrée ou 100 2 (quatre))?

En fait, C (et C ++) ne possède même pas de littéraux binarys intégrés: un littéral numérique commençant par 0 est interprété comme octal , base 8.