Convertisseur decimal-->binaire

International Français
1

Bonjour à tous, je cherche un moyen simple autre que Serial.print(x, BIN) pour convertir une valeur de sortie d'un potentiomètre, donc un int, en byte.
j'ai une variable int qui contient la valeur du potentiomètre.
une autre variable byte qui doit contenir le chiffre binaire correspondant à la valeur du potentiomètre
j'aimerais savoir s'il existe des fonction simple pour le faire.
si j'utilise la fonction bitRead(x,n), qui est censé lire le n-ième bit d'un nombre binaire x, le x peut-il être un décimal ou doit il être nécessairement un nombre binaire ?
Merci beaucoup

2

En C il n'y a pas de conversion nécessaire pour transformer un integer en binaire.
Si par exemple l'interger vaut 100, il vaut 64 en hexadécimal, et 1100100 en binaire.
Par contre on peut l'afficher de différentes manières :
Serial.print(x, HEX)
Serial.print(x, BIN)

J'ai bien peur qu'un byte ne suffise pas pour stocker une valeur analogique (potentiomètre), à moins que tu limites cette valeur à 255.

Un exemple :

  Serial.begin(115200);
  int x = 100;
  for (int n = 15 ; n >= 0 ; n--) {
    Serial.print(bitRead(x, n));
  }
  Serial.println();
  Serial.println(x == 0b01100100 ? "EGAL" : "NON EGAL");

Ce qui affiche bien :
0000000001100100
EGAL

3

donc bitRead peut avec une boucle écrire la valeur binaire de n'importe quelle variable de type int ?
comment puis-je donc stocker le binaire obtenu

4

L'integer est binaire par définition. Seule la représentation visuelle pour l'humain change.
Tout dépend de ce que tu veux faire du résultat. Si tu désires simplement l'afficher utilise Serial.print(x, BIN);
Dans l'exemple précédent :

EGAL est affiché, ce qui prouve bien que 100 est égal à 0b01100100.

5

merci beaucoup

6

oui et même plus qu'un int, ça fonctionne jusqu'aux unsigned long long (64 bits)

testez cela

template <typename T>
void printlnBits(const T valeur) {

  for (int i = 8 * sizeof(T) - 1; i >= 0; --i) {
    Serial.print((byte) bitRead(valeur, i));
  }
  Serial.println(); // passage à la ligne

  // pour montrer qu'on peut afficher ce qu'on veut, pas forcément des 1 et 0
  for (int i = 8 * sizeof(T) - 1; i >= 0; --i) {
    Serial.write(bitRead(valeur, i) == 1 ? '*' : '.');
  }
  Serial.println(); // passage à la ligne
  Serial.println(); // passage à la ligne

}

void setup() {
  Serial.begin(115200);
  printlnBits((uint8_t)  0xF0);                 // 1 octet
  printlnBits((uint16_t) 0xF0F0);               // 2 octets
  printlnBits((uint32_t) 0xF0F0F0);             // 4 octets
  printlnBits((uint64_t) 0xF0F0F0F0F0F0F0F0);   // 8 octets
}

void loop() {}

le moniteur série (à 115200 bauds) affichera

11110000
****....

1111000011110000
****....****....

00000000111100001111000011110000
........****....****....****....

1111000011110000111100001111000011110000111100001111000011110000
****....****....****....****....****....****....****....****....
7

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.