Séparer une variable en 3 ?

**laolahaut** · 19/06/2011, 13h04

Bonjour,
Je programme un PIC en C avec mikroC et mplab et j'aurais quelques questions à vous poser.

J'ai une variable unsigned int de 16bits donc et qui est en BCD.
C'est à dire pour le nombre 22 qui était dans ma variable, je l'ai convertis en BCD pour avoir le nombre 34 (0000 0000 0010 0010 )

Mais je voudrais séparer cette variable en 3 par tranche de 4 bits. ( pour avoir les unités, les dizaines et les centaines )
mais comment faire ?

Est ce que les variables sont comme les registres ?
Exemple : pour selectionner le bit 2 du portA, on fait : PORTA.2 sur mplab
Est ce que pour prendre le bit 2 d'une variable, on fait : variable.2 ?

Dernière question, savez vous pourquoi sur mikroC on utilise "PORTA.F2" pour selectionner le bit 2 ?
Je vous remercie

**Obsidian** · 19/06/2011, 13h28

Bonjour,

En C, comme dans beaucoup d'autres langages, y compris en assembleur, lorsque l'on descend en dessous de la taille du mot élémentaire (byte), il faut utiliser les opérations logiques bit à bit (ET, OU, OU Exclusif, complément) et les décalages pour isoler les champs qui t'intéressent. Donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    variable & 0x000F;
    (variable >> 4) & 0x000F;

Dernière question, savez vous pourquoi sur mikroC on utilise "PORTA.F2" pour selectionner le bit 2 ?

Je ne sais pas comment fonctionnent MPlab et MicroC, mais il y a de fortes chances pour qu'il s'agisse en fait d'une macro #define qui fasse ce travail pour toi.

**laolahaut** · 19/06/2011, 13h56

Ah c'est super, merci bien !!

Petite dernière question : je souhaite convertir la variable BCD en 7 segments. ( donc les 4 premiers bits en 7bits.

J'ai les équations mais je ne pense pas pourvoir l'adapter.
E0 .. E seront les 4 premiers bits d'une variable.

a = E3 | (!E0 & !E2) | (E1 & !E2) | (E2 & E0)
b = !E2 | (!E0 & !E1) | (E0 & E1)
c = !E1 | E0 | E2
d = (!E0 & !E2) | (!E0 & E1) | (E1 & !E2) | (E0 & !E1 & E2)
e = (!E0 & !E2) | (!E0 & E1)
f = (!E0 & !E1) | (!E0 & E2) | E3 | (!E1 & E2)
g = (E1 & !E2) | (!E1 & E2) | E3 | (!E0 & E2);

Mais ce sont des équations issus des tables de karnaugh et ça n'ira pas...

Il n'est pas possible de modifier qu'un seul bit d'une variable tout comme un registre ( !PORTA.3 pour changer le bit 3 )

Merci de votre réponse et de votre patience

**Obsidian** · 19/06/2011, 14h05

Il n'est pas possible de modifier qu'un seul bit d'une variable tout comme un registre ( !PORTA.3 pour changer le bit 3 )

Bien sûr que si, et heureusement. Pour mettre un bit à 1, cela se fait avec un OU logique. Par exemple : 0x80 | 0x01 = 0x81, 0x80 | 0x40 = 0xC0, 0x80 | 0x80 = 0x80. À l'inverse, pour forcer un bit à zéro, on utilise un ET avec le complément du masque ci-dessus. Tout les bits à 1 du masque seront préservés, et les autres forcés à zéro.

Le OU est donc l'équivalent de l'union, et le ET celui de l'intersection.

Tu peux enfin utiliser un OU exclusif pour inverser l'état d'un ou plusieurs bits.

Petite dernière question : je souhaite convertir la variable BCD en 7 segments. ( donc les 4 premiers bits en 7bits. […] Mais ce sont des équations issus des tables de karnaugh et ça n'ira pas...

Si, il est tout-à-fait possible d'y parvenir par le calcul. Mais c'est compliqué pour rien. Le plus simple est de tenir une table de traduction, c'est-à-dire une table de dix octets dont les entrées contiennent les configurations nécessaires à chaque chiffre. Tu utilises ensuite la valeur de ton chiffre en binaire (ou BCD, c'est pareil s'il n'y a qu'un seul chiffre) comme index dans cette table pour aller récupérer directement la bonne valeur.

**davcha** · 19/06/2011, 14h06

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
typedef union T {
  unsigned short value;
  struct {
    unsigned short segment1 : x;
    unsigned short segment2 : y;
    unsigned short segment3 : z;
  };
} T;

Avec x, y et z le nombre de bits pour chaque segment.

Utilisation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
T unT;
unT.value = valeurglobale;
unT.segment1 = ...;
unsigned short a = unT.segment2;

Ce n'est pas ANSI par contre. Et il faut activer les extensions du langage.

**laolahaut** · 19/06/2011, 14h20

Merci de vos réponses,
J'ai bien compris pour modifier un bit :
a = 0b00110011;
Je veux mettre le 3ème LSB à 1 peu importe sa valeur initiale :
a=(a&11111011) | 00000100;
// ça me donnera : 0b00110111

Et je fais pareil pour faire quelque chose de similaire.

Pour ce qui est du BCD/7sgmts, d'accord donc il faut faire avec un switch et les 10 valeurs.. ( 0 à 9 ) voir plus si je veux afficher des lettres.

Mais aurais-tu un exemple pour le faire quand même avec les équations ? ( pas forcément un BCD 7sgmts mais simplement utiliser des équations logiques )
(je dirais avec pleins de if imbriqués .. )

Car je dois faire la conversion pour 3 ou 4 chiffres et je devrais faire un multiplexage en espérant que ça ne mettent pas trop de temps pour que la rétine puisse voir les 3 afficheurs en même temps...
Tout ça pour ne pas avoir 7*4 = 28 sorties pour gérer les 4 afficheurs mais seulement 7+4=11 sorties pour gérer mes 4 afficheurs.

Davcha : merci mais je débute et ça m'a l'air pas mal compliqué , aurais-tu un exemple concret ou alors un nom que je puisse chercher sur google ?

**Sve@r** · 19/06/2011, 15h07

Envoyé par davcha

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
typedef union T {
  unsigned short value;
  struct {
    unsigned short segment1 : x;
    unsigned short segment2 : y;
    unsigned short segment3 : z;
  };
} T;

Avec x, y et z le nombre de bits pour chaque segment.

Utilisation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
T unT;
unT.value = valeurglobale;
unT.segment1 = ...;
unsigned short a = unT.segment2;

Salut

Il faut faire attention avec ce genre de technique car même si ça marche 999999 fois sur 1000000, ce n'est pas conforme à la norme.
Dans la norme sur les unions, on n'a le droit de ne lire que le membre qui a été écrit.
Donc si tu remplis unT.value, tu ne peux aller lire que unT.value. Lire unT.segment1 produit un comportement non garanti (oserais-je dire "indéterminé" ?...)

Envoyé par laolahaut

J'ai bien compris pour modifier un bit :
a = 0b00110011;
Je veux mettre le 3ème LSB à 1 peu importe sa valeur initiale :
a=(a&11111011) | 00000100;
// ça me donnera : 0b00110111?

Pourquoi mettre un "et" sur 11111011 ? Ca n'a aucun effet sur "a" !!!

Tu veux mettre le 3° bit de "a" à 1
a=a | 0x04

Et si tu veux voir si le 4° bit de "a" vaut 1
if (a & 0x08)

Et si tu veux inverser le 5° bit de "a" (le faire passer de 0 à 1 et inversement)
a=a^0x10

Ce mécanisme permet de stocker plusieurs booléens sur une seule variable...

**Obsidian** · 19/06/2011, 15h24

Envoyé par laolahaut

Merci de vos réponses,
J'ai bien compris pour modifier un bit :
a = 0b00110011;
Je veux mettre le 3ème LSB à 1 peu importe sa valeur initiale :
a=(a&11111011) | 00000100;
// ça me donnera : 0b00110111

Tout-à-fait. Sauf que tu n'es pas obligé de mettre d'abord le bit à 0 pour le repasser à 1 ensuite. Donc, tu fais directement « a = a | 00000100 ». Enfin, « 0x40 » plutôt que « 00000100 » parce qu'à ma connaissance, tu ne peux pas directement saisir une constante numérique en binaire dans ton programme C.

Pour ce qui est du BCD/7sgmts, d'accord donc il faut faire avec un switch et les 10 valeurs.. ( 0 à 9 ) voir plus si je veux afficher des lettres.

Non. Pas un switch. Fais directement un tableau.

Mais aurais-tu un exemple pour le faire quand même avec les équations ? ( pas forcément un BCD 7sgmts mais simplement utiliser des équations logiques )
(je dirais avec pleins de if imbriqués .. )

Pourquoi faire ? Les équations elles-mêmes, tu les as écrites toi-même au-dessus.

Car je dois faire la conversion pour 3 ou 4 chiffres et je devrais faire un multiplexage en espérant que ça ne mettent pas trop de temps pour que la rétine puisse voir les 3 afficheurs en même temps...
Tout ça pour ne pas avoir 7*4 = 28 sorties pour gérer les 4 afficheurs mais seulement 7+4=11 sorties pour gérer mes 4 afficheurs.

Oui mais tu ne pilotes pas chaque bit individuellement. Tu envoies des données vers un port dont chaque bit est reliée à une ligne électrique physique, que tu multiplexes ensuite vers l'afficheur de ton choix.

C'est idiot de décomposer sept fois ton chiffre BCD vers le bit correspondant au segment de l'afficheur, pour ensuite les recomposer en une valeur que tu vas balancer au port, et ça l'est encore plus de faire ça à l'exécution et À CHAQUE FOIS ! Ces choses-là doivent être calculées à l'avance, mises dans une table constante et balancées telles quelles. C'est à la fois ce qu'il y a de plus simple et de plus efficace.

**laolahaut** · 19/06/2011, 16h23

Je vous remercie, je suis aller trop vite et il est vrai que j'ai mis un & qui ne sert à rien..

J'ai cru aussi lire dans un cours ce que vous me dites, on ne peut pas directement mettre 0bxxxxxxxx dans le programme mais seulement de l'hexadécimal 0x..

Je vais me renseigner sur les "tableaux" et voir si je peux l'adapter à mon problème.

Mes équations ne seront pas valable, si ?

E3 .. E0 = une partie d'une variable de 8 bits soit : 0111
!E0 indique l'inverse de 1 donc 0 et !E3 indique l'inverse de 0 donc 1 or mes équations ont été faites avec une table de Karnaugh et le !E0 et !X signifie le 0 et donc ça n'ira pas avec E3.. Je dis surement une grosse connerie mais pour en être sûr, je ferai des tests.

Oui mais tu ne pilotes pas chaque bit individuellement. Tu envoies des données vers un port dont chaque bit est reliée à une ligne électrique physique, que tu multiplexes ensuite vers l'afficheur de ton choix.

C'est idiot de décomposer sept fois ton chiffre BCD vers le bit correspondant au segment de l'afficheur, pour ensuite les recomposer en une valeur que tu vas balancer au port, et ça l'est encore plus de faire ça à l'exécution et À CHAQUE FOIS ! Ces choses-là doivent être calculées à l'avance, mises dans une table constante et balancées telles quelles. C'est à la fois ce qu'il y a de plus simple et de plus efficace.

J'ai pas trop compris, voici ce que je comptais faire :

Lire valeur du CAN ( dans variable sur 10bits en binaire ) --> convertir en BCD ( dans variable sur 16bits ) --> décomposer cette variable en 4 variables ( 4 x 4 bits ) --> puis convertir les 4 variables en 7 segments les uns après les autres en les mettant sur le PORTC. ( qui fait 8bits )

en clair :
Nombre lu : 0010110111
Nombre BCD : 0000 0001 1000 0011
Q1 = 0000
Q2 = 0001
Q3 = 1000
Q4 = 0011
Convertir en 7segmts :
AFF1 = 1111110 ( 0 en 7segmts )
AFF2 = 0110000 ( 1 en 7segmts )
AFF3 = 1111111 ( 8 en 7segmts )
AFF4 = 0110011 ( 3 en 7segmts )

Puis je balance les 4 à la suite en modifiant aussi 4 sorties du PORTA qui sélectionnera l'afficheur qui correspond aux unités, dizaines, centaines, milliers ..
J'espère juste que ce sera assez rapide pour jouer sur la persistance rétinienne.
Je ferai une boucle sur les 4 afficheurs en faisant en sorte que je ne lise la valeur sur le CAN que toutes les 500ms. ( si c'est assez rapide pour pouvoir le faire )

Je n'ai pas trouvé d'autres moyens plus facile et plus rapide donc si tu as une idée, je suis preneur

**Obsidian** · 19/06/2011, 17h13

Un tableau, c'est une suite de variables du même type. Lorsque tu écris le code suivant :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

    int t[10];

… tu déclares dix variables de type int consécutives en mémoire et numérotées de t[0] à t[9]. L'avantage, par rapport à déclarer dix variables a, b, c, etc. jusqu'à j est que tu peux utiliser n'importe quelle expression évaluable en nombre entier comme index. Notamment, une autre variable. Par exemple :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
    int i;
    int t[10];
 
    i = 5; t[i] = 42;

… est équivalent à :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

    t[5] = 42;

De là, tu déclares un tableau d'octets constants, puisque la représentation de chaque chiffre sur un afficheur ne varie jamais, et tu les initialises en dur, dans ton code, avec les valeurs adéquates calculées à l'avance.

Ensuite, quand tu veux afficher un chiffre, persistance rétinienne ou pas, tu vas chercher directement la bonne valeur avec t[chiffre] et tu l'envoies telle quelle vers ton port, puisqu'elle contient directement tous les bits nécessaires, à la bonne place :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

 port = t[chiffre];

**laolahaut** · 19/06/2011, 17h27

Oua c'est super, merci bien obsidian

**laolahaut** · 20/06/2011, 22h24

Bonjour,
J'ai un petit problème, j'ai une variable (poids) qui est en int donc 16bits qui est en BCD.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#define TEMPS_CHAQUE_AFFICHEUR 9000
unsigned int volt, poids, t;
unsigned char unite;
unsigned char dizaine;
unsigned char centaine;
unsigned char chiffre[10];
 
void main(void) {
 
// ##### DEBUT DECLARATION CHIFFRE
chiffre[0] = 0x3F;
chiffre[1] = 0x06;
chiffre[2] = 0x5B;
chiffre[3] = 0x4F;
chiffre[4] = 0x66;
chiffre[5] = 0x6D;
chiffre[6] = 0x7D;
chiffre[7] = 0x07;
chiffre[8] = 0x7F;
chiffre[9] = 0x6F;
// ##### FIN DECLARATION CHIFFRE
 
for (;;)
{
 
 poids = Dec2Bcd(562);
 
// ##### Calculer les unités, dizaines, centaines.
unite = poids & 0x000F;    // ne garder que les 4 premiers LSB
dizaine = (poids & 0x00F0) >> 4;
centaine = (poids & 0x0F00) >> 8;
// ##### FIN du calcul des unités, dizaines, centaines.
 
 
for (t = 0; t<10 ; t++ )
{
PORTB = 0x20;
PORTC = chiffre[unite]^0xFF;    // J'inverse tous les bits car mon montage est en anode commune. si je tape directement 0x02^0xFF j'ai bien le 2 qui s'affiche.
for (i=0;i<TEMPS_CHAQUE_AFFICHEUR;i++);
PORTB = 0x40;
PORTC = chiffre[dizaine]^0xFF;
for (i=0;i<TEMPS_CHAQUE_AFFICHEUR;i++);
PORTB = 0x80;
PORTC = chiffre[centaine]^0xFF;
for (i=0;i<TEMPS_CHAQUE_AFFICHEUR;i++);
}
 
}
 
}

J'ai une fonction Dec2Bcd qui convertis en BCD et donc ensuite je tente de récupérer chaque chiffre en prenant 4bits..
Sauf que au final, je n'ai pas ce que je veux.. il m'affiche complètement autre chose et absolument pas le nombre que j'avais convertis.
Est ce que pour vous la méthode pour récupérer les chiffres est juste ou alors c'est un problème au niveau de la fonction Dec2BCD de MikroC ?

Merci

PS : J'ai enlevé les TRIS etc... qui n'a aucun intêret ici car tout fonctionne, idem pour les chiffre[], quand je les affiche en direct, ça fonctionne nickel.

**Obsidian** · 20/06/2011, 23h25

Envoyé par laolahaut

Sauf que au final, je n'ai pas ce que je veux.. il m'affiche complètement autre chose et absolument pas le nombre que j'avais convertis.

Ça a l'air correct à première vue.

Qu'est-ce que tu obtiens ?

**diogene** · 21/06/2011, 12h32

D'après la doc trouvée sur l'ami google de MikroC, on a :

Prototype unsigned short Dec2Bcd(unsigned shortdecnum);
Returns Returns converted BCD value 
Description Converts 8-bit decimal valuedecnum to BCD.
Example unsigned short a;
 ...
 a = Dec2Bcd(52);// equals 0x52

Donc cette fonction ne convient pas dans ce cas.
Se touner plutôt vers :

Prototype unsigned Dec2Bcd16(unsigned decnum);
Returns Returns converted BCD value
Description Converts 16-bit decimal valuedecnum to BCD 
Example unsigned a; 
... 
a = Dec2Bcd16(4660); // equals 1234

A noter, pendant qu'on y est la taille des types entiers (non conforme à la norme pour les shorts). Extrait :

(unsigned) char      8-bit       0 .. 255
signed char          8-bit    -128 .. 127 
(signed) short (int) 8-bit    -128 .. 127 
unsigned short (int) 8-bit       0 .. 255 
(signed) int        16-bit  -32768 .. 32767 
unsigned (int)      16-bit       0 .. 65535

**laolahaut** · 21/06/2011, 13h28

Ah mince d'accord, je n'avais pas vu ça dans l'"help" du logiciel.

ça fonctionne et j'ai mis "int" à la place de char, mais vu que unite,dizaine&centaine n'ont que 4 bits, aucun interet de mettre int donc j'ai voulu mettre char... Je tenterai avec short, si il est compatible avec la norme.

Je te remercie en tout cas