réduire une variable

Bonjour !
Je voudrais savoir comment je pourrais réduire une grosse variable en partant de la gauche : je ne veux garder que le chiffre des unités et des dizaine.
Cette variable comporte actuellement 10 chiffres et dans mes tentatives de conversion, la taille de variable était tout le temps dépassée.
help :drooling_face:

Bonjour,

Elle est sous quelle forme ta variable?

ah oui ^^

c'est une unsigned long (j'ai pas trouvé plus gros)

tu ne peux pas faire tes calculs en flottant?

Il existe aussi des unsigned long long (64 bits), mais je ne pense pas que ce soit la solution

DreiTek:
...............;
comment je pourrais réduire une grosse variable en partant de la gauche : je ne veux garder que le chiffre des unités et des dizaine.
Cette variable comporte actuellement 10 chiffres et dans mes tentatives de conversion, la taille de variable était tout le temps dépassée.
........

Bonsoir,

Je suis curieux, mais quelle grandeur peut donc être représentée par une telle variable ? (pour que la précision ait un sens)

Un dénombrement ?

Serge .D

heu flottant ? si c'est utiliser des float, alors je n'ai pas réussi parce que mes variables prennent des valeurs étranges...

et ce n'est pas pour la précision mais c'est que j'ai 10 leds et chaque chiffre correspond à une led :wink:
peut-être que la solution est de changer cette méthode...

DreiTek:
.............

et ce n'est pas pour la précision mais c'est que j'ai 10 leds et chaque chiffre correspond à une led :wink:
peut-être que la solution est de changer cette méthode...

Bon, comme on n'en sait pas plus, alors peut-être passer en binaire :

  • Une variable byte (8 bits) peut représenter jusqu'a 8 leds et on peut espérer tester n'importe quel bit sans grands calculs.

Par exemple si on déclare : byte Leds=B01101101 Alors :
bitRead(Leds,0) donne 1 (bit n°0 le plus à droite)
bitRead(Leds,1) donne 0
bitRead(Leds,2) donne 1

Serge .D

je viens de voir la commande bitRead…je viens aussi de voir qu’on ne peut pas écrire en binaire sur plus de 8 bits…
Heureusement qu’on peut lire les bits si on écrit en décimal : j’ai juste à convertir mes codes et ce sera bon (normalement)

merci de m’avoir aidé :wink:

DreiTek:
…je viens aussi de voir qu’on ne peut pas écrire en binaire sur plus de 8 bits…
Heureusement qu’on peut lire les bits si on écrit en décimal : j’ai juste à convertir mes codes et ce sera bon (normalement)

Bon de toutes façons le µC est 8 bits et connaît de base l’octet.

Si tu veux 10 leds, alors utilise un int (16 bits).

Pour l’affectation tu peux le faire en bloc avec le décimal (pas pratique pour le traitement bit a bit) :

Par exemple :

  • int Leds=0; // les 16 bits sont à 0
  • int Leds = 1023;// les 10 bits de poids faible sont à 1

(De toutes façons affecter directement en binaire au delà de 8 bits est un peu risqué (risque d’erreur de décalage sur le rang)

Ensuite pour les manipulations il y a aussi les décalages :

  • int Leds = 255;// affecte les 8 bits de poids faible à 1 et les deux autres à 0
  • (Leds <<2);// donnera deux décalages à gauche donc 2 bits de poids faible à 0 et les 8 autres à 1

Et sinon si tu ne crains pas, il y a l’hexadécimal bien pratique avec une écriture compacte et directement liée au binaire …

Etc, etc…

Serge .D

Voir aussi lowByte(Leds); etc… etc

DreiTek:
je viens de voir la commande bitRead...je viens aussi de voir qu'on ne peut pas écrire en binaire sur plus de 8 bits...

Bonjour,

Tu peux écrire en binaire sur autant de bit que tu veux. Simplement les notations B0000000 (qui ne font pas partie du langage C, mais sont simplement des #define comme d'autres constantes) ne vont que jusqu'à B11111111 (1 octet)
Avec bitRead et bitWrite tu peux lire/écrire le numéro de bit que tu veux (le max dépend uniquement de la taille de la variable)

D'ailleurs toutes les variables sont des suites de bits (regroupés en octet), hexa, decimal... c'est simplement une question de représentation par exemple à l'affichage.

kamill:
Bonjour,

Tu peux écrire en binaire sur autant de bit que tu veux. Simplement les notations B0000000 (qui ne font pas partie du langage C, mais sont simplement des #define comme d’autres constantes) ne vont que jusqu’à B11111111 (1 octet)
Avec bitRead et bitWrite tu peux lire/écrire le numéro de bit que tu veux (le max dépend uniquement de la taille de la variable)

D’ailleurs toutes les variables sont des suites de bits (regroupés en octet), hexa, decimal… c’est simplement une question de représentation par exemple à l’affichage.

tout à fait et on peut aussi utiliser les fonctions de décalage de bit pour remplir la partie haute des int ou long

par exemple

byte b;
unsigned int ui;
unsigned long int uli;

void setup() {
  Serial.begin(115200);
  b = B11000011;
  ui = ((unsigned int) B11000011 << 8) + (unsigned int) B11000011;
  uli = ((unsigned long int) B11000011 << 24) + ((unsigned long int) B11000011 << 16) + ((unsigned long int) B11000011 << 8) + (unsigned long int) B11000011;
  Serial.println(b, BIN);
  Serial.println(ui, BIN);
  Serial.println(uli, BIN);
}

void loop() {}

la console affichera

11000011
1100001111000011
11000011110000111100001111000011

qui est bien ce que l’on veut