Récupérer une valeur dans un String

International Français
1

Bonjour à tous,

J'ai un petit souci sur une fonction qui doit me récupérer suite à une calcul simple décimal une valeur Hexadécimal.
Voici le code :

int valeurNumerique = 0;

void setup() {

Serial.begin(115200);

}

void loop() {

valeurNumerique = 104 + 2;

String maValeur = ("Ma valeur = " + String( valeurNumerique, HEX ) + ".");

unsigned int indexDebut = maValeur.indexOf("=");
unsigned int indexFin = maValeur.indexOf(".", indexDebut + 1);
String valeurHexaDetecter = maValeur.substring(indexDebut+1, indexFin);

int valeurHexaTrouver = valeurHexaDetecter.toInt();

Serial.println(String( maValeur ) + "\t" + "Valeur numerique = " + "\t" + String(valeurNumerique) + "\t" + "Index debut = " + String (indexDebut) + "\t" + "Index fin = " + String (indexFin) + "\t" + "Valeur hexa trouver = " + String(valeurHexaDetecter) + "\t" + "Variable hexa = " + "\t" + String(valeurHexaTrouver));
delay(1000);

}

Je récupère bien la valeur hexa avec String valeurHexaDetecter = maValeur.substring(indexDebut+1, indexFin);
mais dès que j'ai une lettre dans le résultat hexa, ma variable int valeurHexaTrouver = valeurHexaDetecter.toInt(); ne l'intègre pas dans une valeur numérique.

Avez vous une solution ?

2

La méthode .toInt() ne fonctionne que pour des entiers codés en base 10.
La conversion s'arrête dès qu'elle rencontre un caractère non numérique.

3

Tu peux utiliser sscanf() pour ça

void setup() {
  Serial.begin(115200);
  // put your setup code here, to run once:
  char chaine[20] = "0x235";
  int valeur = 0;
  Serial.println(valeur);

  sscanf(chaine, "%x", &valeur);
  Serial.println(valeur);
}

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

}

Dans ton cas, avant d'appeler sscanf(), il faudrait utiliser la ligne suivante pour mettre dans chaîne la sous-chaîne contenant le nombre hexadécimal.
valeurHexaDetecter.toChar(chaine, 20);

4

ou juste passer le buffer sous jacent puisque sscanf() est en lecture uniquement et ne va pas modifier le contenu

  if (sscanf(valeurHexaDetecter.c_str(), "%x", &valeur) == 1) {
    // on a réussi à lire un nombre en hexa
    ...
  } else {
    // erreur de lecture, le buffer ne contient pas un nombre en hexa
    ...
  }

On pourrait aussi utiliser la fonction strtoul() qui est moins gourmande en mémoire que sscanf(). Avec comme paramètre pour la base à 0 la fonction détermine automatiquement la base si le texte commence par 0x par exemple il saura que c'est de la base 16.

5

Dans l'exemple, j'obtiens la conversion Hexa / décimal soit 565 dans la variable valeur;
Ce que je souhaites obtenir, c'est la valeur en Hexa, dans mon premier code, mon débug me donne ceci :

Capture
Capture1496×458 61 KB

Pour ma compréhension, la valeur est de 20 dans le tableau de chaine mais pourquoi 20 ?

6

Désolé mais c'est incompréhensible.

  • Mets le code que tu utilises.
  • les valeurs que tu entres
  • ce que tu obtiens
  • et ce que tu attendais
7

Excuse moi, je m'y reprend.

Voici le code que j'utilise :

int valeurNumerique = 0;

void setup() {

Serial.begin(115200);

}

void loop() {

valeurNumerique = 104 + 2;

String maValeur = ("Ma valeur = 0x" + String( valeurNumerique, HEX ) + ".");

unsigned int indexDebut = maValeur.indexOf("=");
unsigned int indexFin = maValeur.indexOf(".", indexDebut + 1);
String valeurHexaDetecter = maValeur.substring(indexDebut+1, indexFin);

Serial.println(String( maValeur ) + "\t" + "Valeur numerique = " + "\t" + String(valeurNumerique) + "\t" + "Valeur string hexa trouver = " + String(valeurHexaDetecter));
delay(1000);

}

String maValeur = ("Ma valeur = 0x" + String( valeurNumerique, HEX ) + "."); // création d'un String contenant le résultat hexadecimal de mon calcul

Je fais ensuite la recherche avec indexOf pour trouver les caractères à retrouver qui se trouve dans la variable valeurHexaDetecter

Je souhaite en finalité récupérer le contenu de valeurHexaDetecter et l'intégrer dans une variable int valeurHexa; et qui a le même format que valeurHexaDetecter

Voici mon moniteur série :

Capture
Capture945×423 35.9 KB

8

Parce que tu fais chercher le caractère "=" donc le caractère juste derrière est l'espace entre "=" et "0" et le code ASCII de l'espace c'est 0x20

On t'a donné la réponse au #3 et au #4.

9

Bonsoir udina

Trouvé grâce à l'IA en posant la question:

en Arduino, comment récupérer la valeur décimale d'une String qui représente de l'hexadécimal et qui vaut 0x6A

void setup() {
  Serial.begin(115200);

  // Chaîne hexadécimale
  String hexString = "0x6A";

  // Conversion en décimal
  long decimalValue = strtol(hexString.c_str(), NULL, 16);

  // Affichage du résultat
  Serial.print("Valeur hexadécimale : ");
  Serial.println(hexString);
  Serial.print("Valeur décimale : ");
  Serial.println(decimalValue);
}

void loop() {
  // Rien à faire ici
}

image

Cordialement
jpbbricole

10

Vous n’utilisez pas un terminal qui reconnaît l’UTF8 ou c’est chatGPT qui vous a mis du texte non UTF8 dans le code ? (Les accents ne sont pas bien interprétés)

11

Non, c'est Tinkercad.

12

ah.. ça m'énerverait de voir cela ! :slight_smile:

13

juste pour être sûr. Quand vous lisez une valeur codée en Hexadécimal avec sscanf ou strtoul, vous obtenez un nombre. Ce nombre est représenté dans la mémoire de l'arduino en base 2 (des 0 et de 1). obtenir une valeur hexadécimale, ça ne veut pas dire grand chose en soi, c'est juste une convention d'écriture à 'écran

void setup() {
  uint16_t valeur = 0x20; 
  Serial.begin(115200);
  Serial.print("En décimal : ");       Serial.println(valeur, DEC); // le DEC est optionnel, c'est la valeur par défaut
  Serial.print("En Hexadécimal : 0x"); Serial.println(valeur, HEX);
  Serial.print("En Binaire : 0b");     Serial.println(valeur, BIN);
}

void loop() {}
14

Oui, c'est bien ça, c'est une valeur entière correspondante à la valeur hexadécimal. je commence à comprendre le principe et finalement, la piste IA de JPB m'aide aussi dans cette compréhension sans vous embêter avec des questions "bêtes".
Dans mon projet d'analyseur BUSCAN présent sur un autre sujet, je suis en train de créer des tableaux de valeur hexadecimal qui doivent remplir des valeurs de filtres de trame BUSCAN. J'ai six tableaux à créer pour six filtres :

const ACAN2515Mask rxm0 = standard2515Mask(0x7FF, 0, 0);
const ACAN2515Mask rxm1 = standard2515Mask(0x7FF, 0, 0);

  const ACAN2515AcceptanceFilter filters[] = {
    { standard2515Filter(tableauDeFiltreStandardUn, 0, 0), messageStandardUn },          // RXF0
    { standard2515Filter(tableauDeFiltreStandardDeux, 0, 0), messageStandardDeux },      // RXF1
    { standard2515Filter(tableauDeFiltreStandardTrois, 0, 0), messageStandardTrois },    // RXF2
    { standard2515Filter(tableauDeFiltreStandardQuatre, 0, 0), messageStandardQuatre },  // RXF3
    { standard2515Filter(tableauDeFiltreStandardCinq, 0, 0), messageStandardCinq },      // RXF4
    { standard2515Filter(tableauDeFiltreStandardSix, 0, 0), messageStandardSix }         // RXF5
  };

const uint16_t errorCode = can.begin(settings, [] { can.isr(); },
rxm0,                                                                                    // Configuration de la valeur RXM0 register
rxm1,                                                                                    // Configuration de la valeur RXM1 register filters,
filters,                                                                                 // tableau des filtres
6);                                                                                      // taille du tableau des filtres

Voici le type de tableau que je crée :

int tableauDeFiltreStandardUn[]{
    0x1,   0x7,   0xD, 0x13,   0x19,  0x1F,  0x25,  0x2B,  0x31,  0x37,  0x3D,  0x43,  0x49,  0x4F,  0x55,  0x5B,  0x61,  0x67,  0x6D,  0x73,  0x79,  0x7F,  0x85,  0x8B,  0x91,  0x97, 0x9D, 0xA3,
   0xA9,  0xAF,  0xB5, 0xBB,   0xC1,  0xC7,  0xCD,  0xD3,  0xD9,  0xDF,  0xE5,  0xEB,  0xF1,  0xF7,  0xFD, 0x103, 0x109, 0x10F, 0x115, 0x11B, 0x121, 0x127, 0x12D, 0x133, 0x139, 0x13F,
  0x145, 0x14B, 0x151, 0x157, 0x15D, 0x163, 0x169, 0x16F, 0x175, 0x17B, 0x181, 0x187, 0x18D, 0x193, 0x199, 0x19F, 0x1A5, 0x1AB, 0x1B1, 0x1B7, 0x1BD, 0x1C3, 0x1C9, 0x1CF,
  0x1D5, 0x1DB, 0x1E1, 0x1E7, 0x1ED, 0x1F3, 0x1F9, 0x1FF, 0x205, 0x20B, 0x211, 0x217, 0x21D, 0x223, 0x229, 0x22F, 0x235, 0x23B, 0x241, 0x247, 0x24D, 0x253, 0x259, 0x25F,
  0x265, 0x26B, 0x271, 0x277, 0x27D, 0x283, 0x289, 0x28F, 0x295, 0x29B, 0x2A1, 0x2A7, 0x2AD, 0x2B3, 0x2B9, 0x2BF, 0x2C5, 0x2CB, 0x2D1, 0x2D7, 0x2DD, 0x2E3, 0x2E9, 0x2EF,
  0x2F5, 0x2FB, 0x301, 0x307, 0x30D, 0x313, 0x319, 0x31F, 0x325, 0x32B, 0x331, 0x337, 0x33D, 0x343, 0x349, 0x34F, 0x355, 0x35B, 0x361, 0x367, 0x36D, 0x373, 0x379, 0x37F,
  0x385, 0x38B, 0x391, 0x397, 0x39D, 0x3A3, 0x3A9, 0x3AF, 0x3B5, 0x3BB, 0x3C1, 0x3C7, 0x3CD, 0x3D3, 0x3D9, 0x3DF, 0x3E5, 0x3EB, 0x3F1,
  
};

Les valeurs hexadécimal vont de six en six dans chaque tableau :

  • tableau 1 => valeur de départ 1
  • tableau 2 => valeur de départ 2
  • tableau 3 => valeur de départ 3
  • ect ...

J'ai un encodeur qui à chaque incrémentation va me faire bouger dans ces tableaux.
Au vu de la répétition des valeurs, je voulais partir sur une addition simple du genre :

tableau 1 : 1 + 6 | 7 + 6 | 13 + 6 ect...
tableau 2 : 2 + 6 ect...
tableau 3 : 3 + 6 ect...

Donc dans ma variable tableauDeFiltreStandardUn[]{} l'affichage est de type hexa ( 0x1, 0x7, 0xD, 0x13, 0x19, 0x1F, 0x25, 0x2B ... )
Après récupération par sscanf() strtoul(), la valeur entière sera elle reconnue dans la bibliothèque ACAN ?

15

l'affichage c'est juste pour vous.

le tableau peut être déclaré

en héxadécimal (base 16)

int tableauDeFiltreStandardUn[] {
  0x1,   0x7,   0xD, 0x13,   0x19,  0x1F,  0x25,  0x2B,  0x31,  0x37,  0x3D,  0x43,  0x49,  0x4F,  0x55,  0x5B,  0x61,  0x67,  0x6D,  0x73,  0x79,  0x7F,  0x85,  0x8B,  0x91,  0x97, 0x9D, 0xA3,
  0xA9,  0xAF,  0xB5, 0xBB,   0xC1,  0xC7,  0xCD,  0xD3,  0xD9,  0xDF,  0xE5,  0xEB,  0xF1,  0xF7,  0xFD, 0x103, 0x109, 0x10F, 0x115, 0x11B, 0x121, 0x127, 0x12D, 0x133, 0x139, 0x13F,
  0x145, 0x14B, 0x151, 0x157, 0x15D, 0x163, 0x169, 0x16F, 0x175, 0x17B, 0x181, 0x187, 0x18D, 0x193, 0x199, 0x19F, 0x1A5, 0x1AB, 0x1B1, 0x1B7, 0x1BD, 0x1C3, 0x1C9, 0x1CF,
  0x1D5, 0x1DB, 0x1E1, 0x1E7, 0x1ED, 0x1F3, 0x1F9, 0x1FF, 0x205, 0x20B, 0x211, 0x217, 0x21D, 0x223, 0x229, 0x22F, 0x235, 0x23B, 0x241, 0x247, 0x24D, 0x253, 0x259, 0x25F,
  0x265, 0x26B, 0x271, 0x277, 0x27D, 0x283, 0x289, 0x28F, 0x295, 0x29B, 0x2A1, 0x2A7, 0x2AD, 0x2B3, 0x2B9, 0x2BF, 0x2C5, 0x2CB, 0x2D1, 0x2D7, 0x2DD, 0x2E3, 0x2E9, 0x2EF,
  0x2F5, 0x2FB, 0x301, 0x307, 0x30D, 0x313, 0x319, 0x31F, 0x325, 0x32B, 0x331, 0x337, 0x33D, 0x343, 0x349, 0x34F, 0x355, 0x35B, 0x361, 0x367, 0x36D, 0x373, 0x379, 0x37F,
  0x385, 0x38B, 0x391, 0x397, 0x39D, 0x3A3, 0x3A9, 0x3AF, 0x3B5, 0x3BB, 0x3C1, 0x3C7, 0x3CD, 0x3D3, 0x3D9, 0x3DF, 0x3E5, 0x3EB, 0x3F1,
};

ou en binaire (base 2)

int tableauDeFiltreStandardUn[] {
  0b0000000001, 0b0000000111, 0b0000001101, 0b0000010011, 0b0000011001, 0b0000011111, 0b0000100101, 0b0000101011,
  0b0000110001, 0b0000110111, 0b0000111110, 0b0001000011, 0b0001001001, 0b0001001111, 0b0001010101, 0b0001011011,
  0b0001100001, 0b0001100111, 0b0001101101, 0b0001110011, 0b0001111001, 0b0001111111, 0b0010000101, 0b0010001011,
  0b0010010001, 0b0010010111, 0b0010011101, 0b0010100011, 0b0010101001, 0b0010101111, 0b0010110101, 0b0010111011,
  0b0011000001, 0b0011000111, 0b0011001101, 0b0011010011, 0b0011011001, 0b0011011111, 0b0011100101, 0b0011101011,
  0b0011110001, 0b0011110111, 0b0011111101, 0b0100000011, 0b0100001001, 0b0100001111, 0b0100010101, 0b0100011011,
  0b0100100001, 0b0100100111, 0b0100101101, 0b0100110011, 0b0100111001, 0b0100111111, 0b0101000101, 0b0101001011,
  0b0101010001, 0b0101010111, 0b0101011101, 0b0101100011, 0b0101101001, 0b0101101111, 0b0101110101, 0b0101111011,
  0b0110000001, 0b0110000111, 0b0110001101, 0b0110010011, 0b0110011001, 0b0110011111, 0b0110100101, 0b0110101011,
  0b0110110001, 0b0110110111, 0b0110111101, 0b0111000011, 0b0111001001, 0b0111001111, 0b0111010101, 0b0111011011,
  0b0111100001, 0b0111100111, 0b0111101101, 0b0111110011, 0b0111111001, 0b0111111111, 0b1000000101, 0b1000001011,
  0b1000010001, 0b1000010111, 0b1000011101, 0b1000100011, 0b1000101001, 0b1000101111, 0b1000110101, 0b1000111011,
  0b1001000001, 0b1001000111, 0b1001001101, 0b1001010011, 0b1001011001, 0b1001011111, 0b1001100101, 0b1001101011,
  0b1001110001, 0b1001110111, 0b1001111101, 0b1010000011, 0b1010001001, 0b1010001111, 0b1010010101, 0b1010011011,
  0b1010100001, 0b1010100111, 0b1010101101, 0b1010110011, 0b1010111001, 0b1010111111, 0b1011000101, 0b1011001011,
  0b1011010001, 0b1011010111, 0b1011011101, 0b1011100011, 0b1011101001, 0b1011101111, 0b1011110101, 0b1011111011,
  0b1100000001, 0b1100000111, 0b1100001101, 0b1100010011, 0b1100011001, 0b1100011111, 0b1100100101, 0b1100101011,
  0b1100110001, 0b1100110111, 0b1100111101, 0b1101000011, 0b1101001001, 0b1101001111, 0b1101010101, 0b1101011011,
  0b1101100001, 0b1101100111, 0b1101101101, 0b1101110011, 0b1101111001, 0b1101111111, 0b1110000101, 0b1110001011,
  0b1110010001, 0b1110010111, 0b1110011101, 0b1110100011, 0b1110101001, 0b1110101111, 0b1110110101, 0b1110111011,
  0b1111000001, 0b1111000111, 0b1111001101, 0b1111010011, 0b1111011001, 0b1111011111, 0b1111100101, 0b1111101011,
  0b1111110001, 0b1111110111, 0b1111111101, 0b10000000011, 0b10000001001, 0b10000001111,
};

ou en décimal (base 10)

int tableauDeFiltreStandardUn[] {
  1, 7, 13, 19, 25, 31, 37, 43, 49, 55, 61, 67, 73, 79, 85, 91, 97, 103, 109, 115, 121, 127, 133, 139,
  145, 151, 157, 163, 169, 175, 181, 187, 193, 199, 205, 211, 217, 223, 229, 235, 241, 247, 253, 259, 265, 271, 277, 283,
  289, 295, 301, 307, 313, 319, 325, 331, 337, 343, 349, 355, 361, 367, 373, 379, 385, 391, 397, 403, 409, 415, 421, 427,
  433, 439, 445, 451, 457, 463, 469, 475, 481, 487, 493, 499, 505, 511, 517, 523, 529, 535, 541, 547, 553, 559, 565, 571,
  577, 583, 589, 595, 601, 607, 613, 619, 625, 631, 637, 643, 649, 655, 661, 667, 673, 679, 685, 691, 697, 703, 709, 715,
  721, 727, 733, 739, 745, 751, 757, 763, 769, 775, 781, 787, 793, 799, 805, 811, 817, 823, 829, 835, 841, 847, 853, 865,
  871, 877, 883, 889, 895, 901, 907, 913, 919, 925, 931, 937, 943, 949, 955, 961, 967, 973, 979, 985, 991, 997, 1003,
};

ou encore en octal (base 8)

int tableauDeFiltreStandardUn[] {
  01, 07, 015, 023, 031, 037, 045, 053, 061, 067, 075, 0103, 0111, 0117, 0125, 0133,
  0141, 0147, 0155, 0163, 0171, 0177, 0205, 0213, 0221, 0227, 0235, 0243, 0251, 0257,
  0265, 0273, 0301, 0307, 0315, 0323, 0331, 0337, 0345, 0353, 0361, 0367, 0375, 0403,
  0411, 0417, 0425, 0433, 0441, 0447, 0455, 0463, 0471, 0477, 0505, 0513, 0521, 0527,
  0535, 0543, 0551, 0557, 0565, 0573, 0601, 0607, 0615, 0623, 0631, 0637, 0645, 0653,
  0661, 0667, 0675, 0703, 0711, 0717, 0725, 0733, 0741, 0747, 0755, 0763, 0771, 0777,
  01005, 01013, 01021, 01027, 01035, 01043, 01051, 01057, 01065, 01073, 01101, 01107,
  01115, 01123, 01131, 01137, 01145, 01153, 01161, 01167, 01175, 01203, 01211, 01217,
  01225, 01233, 01241, 01247, 01255, 01263, 01271, 01277, 01305, 01313, 01321, 01327,
  01335, 01343, 01351, 01357, 01365, 01373, 01401, 01407, 01415, 01423, 01431, 01437,
  01445, 01453, 01461, 01467, 01475, 01503, 01511, 01517, 01525, 01533, 01541, 01547,
  01555, 01563, 01571, 01577, 01605, 01613, 01621, 01627, 01635, 01643, 01651, 01657,
  01665, 01673, 01701, 01707, 01715, 01723, 01731, 01737, 01745, 01753, 01761, 01767,
  01775, 02003, 02011, 02017, 02025, 02033, 02041, 02047, 02055, 02063, 02071, 02077,
  02105, 02113, 02121, 02127, 02135, 02143, 02151, 02157, 02165, 02173, 02201, 02207,
  02215, 02223, 02231, 02237, 02245, 02253, 02261, 02267, 02275, 02303, 02311, 02317,
  02325, 02333, 02341, 02347, 02355, 02363, 02371, 02377, 02405, 02413, 02421, 02427,
  02435, 02443, 02451, 02457, 02465, 02473, 02501, 02507, 02515, 02523, 02531, 02537,
  02545, 02553, 02561, 02567, 02575, 02603, 02611, 02617, 02625, 02633, 02641, 02647,
  02655, 02663, 02671, 02677, 02705, 02713, 02721, 02727, 02735, 02743, 02751, 02757,
  02765, 02773, 03001, 03007, 03015, 03023, 03031, 03037, 03045, 03053, 03061, 03067,
  03075, 03103, 03111, 03117, 03125, 03133, 03141, 03147, 03155, 03163, 03171, 03177,
  03205, 03213, 03221, 03227, 03235, 03243, 03251, 03257, 03265, 03273, 03301, 03307,
  03315, 03323, 03331, 03337, 03345, 03353, 03361, 03367, 03375, 03403, 03411, 03417,
  03425, 03433, 03441, 03447, 03455, 03463, 03471, 03477, 03505, 03513, 03521, 03527,
  03535, 03543, 03551, 03557, 03565, 03573, 03601, 03607, 03615, 03623, 03631, 03637,
  03645, 03653, 03661, 03667, 03675, 03703, 03711, 03717, 03725, 03733, 03741, 03747,
  03755, 03763, 03771, 03777, 04003, 04011, 04017, 04025, 04033, 04041, 04047, 04055,
  04063, 04071, 04077, 04105, 04113, 04121, 04127, 04135, 04143, 04151, 04157, 04165,
  04173, 04201, 04207, 04215, 04223, 04231, 04237, 04245, 04253, 04261, 04267, 04275,
  04303, 04311, 04317, 04325, 04333, 04341, 04347, 04355, 04363, 04371, 04377, 04405,
  04413, 04421, 04427, 04435, 04443, 04451, 04457, 04465, 04473, 04501, 04507, 04515,
  04523, 04531, 04537, 04545, 04553, 04561, 04567, 04575, 04603, 04611, 04617, 04625,
  04633, 04641, 04647, 04655, 04663, 04671, 04677, 04705, 04713, 04721, 04727, 04735,
  04743, 04751, 04757, 04765, 04773, 05001, 05007, 05015, 05023, 05031, 05037, 05045,
  05053, 05061, 05067, 05075, 05103, 05111, 05117, 05125, 05133, 05141, 05147, 05155,
  05163, 05171, 05177, 05205, 05213, 05221, 05227, 05235, 05243, 05251, 05257, 05265,
};

➜ C'est exactement le même tableau en mémoire, j'ai juste utilisé une convention de représentation des nombres reconnue par le compilateur. (ne vérifiez pas les valeurs, c'est juste un exemple, je ne vous garanti pas que ce sont toutes les mêmes - j'ai généré les équivalence par chatGPT pour ne pas m'embêter)

Vous pouvez même mélanger les représentations dans l'écriture du tableau

int tableauDeFiltreStandardUn[] {
  0x1,   0x7,   0xD, 0x13,   0x19,  0x1F,  0x25,  0x2B,  0x31,  0x37,  0x3D,  0x43,  0x49,  0x4F,  0x55,  0x5B,  0x61,  0x67,  0x6D,  0x73,  0x79,  0x7F,  0x85,  0x8B,  0x91,  0x97, 0x9D, 0xA3,
  0b0000110001, 0b0000110111, 0b0000111110, 0b0001000011, 0b0001001001, 0b0001001111, 0b0001010101, 0b0001011011,
  289, 295, 301, 307, 313, 319, 325, 331, 337, 343, 349, 355, 361, 367, 373, 379, 385, 391, 397, 403, 409, 415, 421, 427,
  0411, 0417, 0425, 0433, 0441, 0447, 0455, 0463, 0471, 0477, 0505, 0513, 0521, 0527,
...

Ça n'a aucune importance, du moment que la représentation "humaine" (textuelle) permet de déterminer la base utilisée (par défaut décimal, si on commence par 0x c'est de l'hexadécimal, si on commence par 0b c'est du binaire, si on commence par 0 c'est de l'octal).

Une fois la valeur en mémoire, c'est la valeur utilisée. Peut importe comment vous voulez la représenter à l'affichage. Votre 'BUSCAN' s'en fiche, il travaille avec les octets que vous lui passez.

16

Super, merci beaucoup pour cette clarification !
Ça me parait plus clair

17

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