Version imprimable
C'est bien ça ?
Code:
2
3
4
5
6
7
8
Oui, avec juste deux petites erreurs car ta boucle ne décale que de 7 fois. Tu vas de 1 à 7 int i=1;i<8;i++ en démarrant i à 0 c'est bon int i=0;i<8;i++ et avec mikroC pour déclarer une variable sur 16 bits on la déclarera dans notre cas à nous, en unsigned int https://download.mikroe.com/document...etic_types.htmCitation:
Envoyé par sparow1
Ça donne ceci :
Code:
2
3
4
5
6
7
8
9
Allons un peu plus loin, en bouclant tout ça, histoire que le chenillard tourne tout le temps (en vrai je vais me limiter à 3 fois pour ne pas faire une boucle infinie) en faisant tourner la même donnée qui est dans ma_variable_8bits. En gros ça va donner ça.
Pièce jointe 557756
J'ai juste ajouté une boucle for au dessus de la tienne et ajouté une ligne de code à la fin.
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
Ici, il est très important que tu comprennes bien cette ligne ma_variable_16bits = ma_variable_16bits + ma_variable_8bits; qui est très différente de ma_variable_16bits = ma_variable_8bits;.
ma_variable_16bits = ma_variable_8bits; signifie, j'écrase tout ce qu'il y a dans ma_variable_16bits (donc je mets son contenue à 0) et j'affecte ma_variable_8bit dedans. Peut importe si ma_variable_8bit occupe que la moitié de ma_variable_16bit ça va tout écraser.
ma_variable_16bits = ma_variable_16bits + ma_variable_8bits; ne fait pas la même chose. Ici on dira ; je prends ma_variable_16bits, je mets dedans son propre contenu (donc on ne remets pas son contenu à 0) et j'ajoute ma_variable_8bit.
Avant de passer à la dernière étape, celle qui te bloque ou comment affecter mes broches RB1_bit, RB2_bit, ... à l'octet de poid fort de ma_variable_16bits, il faut vraiment que tu aies compris tout ce que je viens d'écrire depuis ton message où tu dis ne pas avoir compris. Dans l'étape d'après on va devoir faire des masques binaire du genre RB7_bit doit prendre la valeur du bit numéro 14 de ma_variable_16bits. Il faut vraiment que tout soit clair. Tu peux aussi programmer sur un PC pour faire des essais, moi c'est ce que je fais pour dégrossir, au lieu d'allumer des LED j'affiche des printf que je décode en binaire.
Pièce jointe 557760
Oui juste, je commence toujours à 0, erreur d'inattention de ma part.
Pas l'habitude, des chars. On pourrait mettre des int partout, mais ce n'est pas le plus optimisé effectivement.
J'aurais une question, lorsqu'on arrive ici :
ma_variable_16bits vaut 10101010 10101010 ?Code:ma_variable_16bits = ma_variable_16bits + ma_variable_8bits;
Pour faire vérifier directement les résultats tu utilises quoi ? Ici je suis sur codeblocks, mais je ne sais pas si c'est le mieux pour pouvoir compiler pour vérifier.
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
Exact ! Et dès qu'on ré-entre dans la boucle sa re-décale à gauche, ainsi de suite.Citation:
Envoyé par sparow1
J'ai juste une fonction affiche() qui affiche à l'écran du binaire sur 16 bits.Citation:
Envoyé par sparow1
Cette ligne n'est pas compliqué, c'est l'opérateur ternaire (d & 0x8000) ? 1 : 0 on peut décortiquer le bidule en disant ceci :
- si (d & 0x8000) est vrai alors on retourne 1, si (d & 0x8000), est faux alors on retourne 0. Comme je suis sous Linux, j'utilise directement GCC mais sous Windows avec n'importe quel compilateur ça doit marcher.
Code:
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
Résultat + ajout de mes commentaires (si tu regardes l'octet de poids fort, colonne de gauche, ça donne bien l'illusion que la donnée avance. La colonne de droite étant une sorte de zone où on charge la donnée qui sera décalée pour être affichée par la colonne de gauche)
Comme tu sembles avoir tout compris, ce soir j'écris la suite, le noeud du problème en quelque sorte, comment allumer les LED en fonction de ça. Note bien ce que j'ai écrit sur l'opérateur ternaire (d & 0x8000) ? 1 : 0 car il n'est finalement qu'une écriture "contractée" de ce que je vais faire avec les RBx_bit. Tu as même un aperçu exacte de la suite dans la fonction affiche().Citation:
00000000 10101010 <= ici on voit ma_variable_16bits = ma_variable_8bits; avec l'écrasement des bits de poids fort.
00000001 01010100
00000010 10101000
00000101 01010000
00001010 10100000
00010101 01000000
00101010 10000000
01010101 00000000
10101010 10101010 <= ici on voit ma_variable_16bits = ma_variable_16bits + ma_variable_8bits;
01010101 01010100
10101010 10101000
01010101 01010000
10101010 10100000
01010101 01000000
10101010 10000000
01010101 00000000
10101010 10101010
01010101 01010100
10101010 10101000
01010101 01010000
10101010 10100000
01010101 01000000
10101010 10000000
01010101 00000000
A toute.
Bon, comme tu l'as compris le code d'avant est une sorte de "buffer" circulaire. On charge une donnée dans ma_variable_16bits et fait tourner la donnée sur elle même à l'aide de 2 boucles for imbriquées. On le fait trois fois de suite mais on pourrait le faire indéfiniment comme les messages qui défilent sur certain afficheur.
Pièce jointe 557895
Maintenant c'est la partie qui te posait problème. Comment faire pour que tes LED s'allument au rythme de la donnée qui avance et sachant que le déclaration de RBx_bit dans ton compilateur est plutôt contraignante. On va faire RB1_bit, RB2_bit et RB7_bit et pour le reste je te laisserai le faire. C'est le dessin ci-dessous qui servira à faire l'analyse du problème.
Pièce jointe 557903
On commence par RB1_bit qui est à rattacher au bit n°8 de la variable ma_variable_16bits. Ce qu'on cherche donc c'est à savoir si le bit n°8 est à 1 ou à 0, si il est à 1 on fera RB1_bit = 1 ; et si il est à 0 on fera RB1_bit = 0 ; tout simplement. C'est d'ailleurs ce que tu fais dans ton code initial.
Pour savoir si un bit précis vaut 1 ou 0 dans une variable on fait un masque binaire en s'appuyant sur la logique booléenne et les tables de vérité plus particulièrement. En voici deux :
Table de vérité de ET a b a ET b 0 0 0 0 1 0 1 0 0 1 1 1
Table de vérité de OU a b a OU b 0 0 0 0 1 1 1 0 1 1 1 1
C'est la table ET qui va nous intéresser pour savoir si le bit 8 précis est à 1 ou a 0, parce que la valeur 1 ET quelque chose, ça donne ce quelque chose dans la table de vérité (en vert). On va donc poser SI ma_variable_16bits ET masquebinaire == vrai ALORS RB1_bit = 1 ; SINON RB1_bit = 0 ;
Donc avant le décalage, on va juste écrireCode:
2
3
4
5
610101010 00000000 (c'est ma_variable_16bits) & 00000001 00000000 (je mets les bits qui ne m’intéresse pas à 0 sauf le bit n°8 avec un masque qui vaut 0x0100) --------------------------- = 00000000 00000000 (le résultat est 0 donc faux)
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Pour le bit n°9 attaché à RB2_bit :
Code:
2
3
4
5
610101010 00000000 (c'est ma_variable_16bits) & 00000010 00000000 (je mets les bits qui ne m’intéresse pas à 0 sauf le bit n°9 avec un masque qui vaut 0x0200) --------------------------- = 00000010 00000000 (le résultat est 512 en décimal ou encore 0x0200 en hexa, donc vrai car en C tout ce qui n'est pas 0 et vrai !)
Code:
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
Concernant RB7_bit rattaché au bit n°14 de ma_variable16bits
Code:
2
3
4
5
610101010 00000000 (c'est ma_variable_16bits) & 00000010 00000000 (je mets les bits qui ne m’intéresse pas à 0 sauf le bit n°14 avec un masque qui vaut 0x4000) --------------------------- = 00000010 00000000 (le résultat est 0 donc faux)
Code:
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
Ainsi de suite pour les autres RBx_bit (j'ai fait les deux premiers et le dernier).
As tu compris le principe ?
ps : je t'ai donné la table de vérité OU pour une bonne raison (sécurisation d'une ligne de code qu'on a vu au début) mais si tu n'as pas compris tout ce que j'ai écrit au dessus, les opérations binaires, tu ne comprendras peut être pas la subtilité du OU.
Pourquoi doit-on passer par un masque binaire et ne peut-on pas prendre la donnée du bit directement ?
0x0100 c'est bien l'équivalent de 0b0000000100000000 ?
Sinon oui j'ai compris :
Code:
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
Mais pour le mettre en forme de boucle ?
Et je comprends, mais pour quel ligne le OU logique ?
Exacte ! Avec le temps j'ai pris l'habitude de tout écrire en hexa, 0x0100 car beaucoup de compilateur ne savent pas ce qu'est 0b0000000100000000 pour le binaire. Je te recommande vivement de ne pas abuser du 0b car si un jour tu bosses sur un autre microcontrôleur (AVR, MSP430, STM32, ...) tu peux avoir une mauvaise surprise, si il n'existe pas. L'hexa avec 0x ça c'est normalisé et tous les compilateurs C savent ce que c'est.Citation:
Envoyé par sparow1
Tu penses à quoi quand tu dis pourquoi ne peut-on pas prendre la donnée du bit ? En langage C il n'y a pas d'instruction pour aller voir la valeur d'un bit en particulier. Si dans mikroC il y en a une alors c'est certain qu'elle utilise un masque binaire. Une exemple qu'on rencontre énormément en programmation sur microcontrôleur :Citation:
Envoyé par sparow1
TRISB = 0b11111111; //port B en entrée
J'ai des boutons poussoir sur RB0, RB4 et RB5, je veux que mon programme fasse quelque chose lorsque c'est 3 bits sont a 1 (quand l'utilisateur a appuyé sur les 3 boutons en même temps), en fait ce que je veux c'est regarder que ces 3 bits, les autres ne m'intéresse pas et d'ailleurs je n'ai aucune idée de leur état (1 ou 0, on ne sait pas ?)
Imaginons PORTB = 0b??11???1 ? = aucune idée
Ici il n'y a pas d'autre solution que le masque binaire, la solution est if((PORTB & 0x20 == 1) && (PORTB & 0x10 == 1) && (PORTB & 0x01 == 1)) { /* donc les 3 bits à 1 */ }
Je pense qu'il vaut mieux faire ma_variable_16bits = ma_variable_16bits | ma_variable_8bits; plutôt que ma_variable_16bits = ma_variable_16bits + ma_variable_8bits; pour charger ma_variable_8bits dans l'octet de poids faible de ma_variable_16bits. Le OU permet de mettre des bits à 1 les bits qu'on souhaite sans se préoccuper des autres en quelques sortes, c'est l'inverse du ET. Le + étant une addition il pourrait dans certain cas affecter l'octet de poids fort alors qu'on ne voulait pas.Citation:
Envoyé par sparow1
****************************************************
Le programme donnerai donc ceci (a essayer car je n'ai pas mikroC, je n'ai pas pu compiler et la dernière fois que j'ai programmé des PIC j'avais ton age :aie:) :
Code:
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
D'accord, je vais essayer de m'habituer à l'hexa.
Je comprends mieux, merci.
J'ai plusieurs erreurs en compilant et je n'arrive pas à les résoudre. Se serait possible de décaler en message privé pour éviter d’inonder le forum ?
Il vaut mieux le faire ici :Citation:
Envoyé par sparow1
- pour que ça profite au plus grand nombre, c'est le but premier de ce forum.
- car d'autres peuvent aussi apporter de l'aide, il n'y a pas que moi ici qui programme des microcontrôleurs.
A+
D'accord, voici les erreurs indiqués :
0 1139 Available RAM: 208 [bytes], Available ROM: 2048 [bytes]
0 122 Compilation Started chenillard.c
16 315 Invalid expression chenillard.c
14 402 ; expected, but 'unsigned' found chenillard.c
16 424 '}' expected ';' found chenillard.c
24 371 Specifier needed chenillard.c
24 396 Invalid declarator expected'(' or identifier chenillard.c
36 315 Invalid expression chenillard.c
36 402 ; expected, but 'int' found chenillard.c
36 324 Undeclared identifier 'j' in expression chenillard.c
36 324 Undeclared identifier 'j' in expression chenillard.c
36 425 ')' expected, but ';' found chenillard.c
36 324 Undeclared identifier 'j' in expression chenillard.c
36 402 ; expected, but ')' found chenillard.c
37 424 '}' expected ';' found chenillard.c
40 1503 Result is not defined in function: '' chenillard.c
40 312 Internal error '' chenillard.c
0 102 Finished (with errors): 19 avr. 2020, 21:12:40 chenillard.mcppi
Poste ton code aussi
C'est ce que tu avais mis
Code:
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
La seule erreur est à cette ligne LED1(donnee, 10)) avec une parenthèse de trop.
Ce log est bizarre on dirait celui d'un autre soft ???
0 1139 Available RAM: 208 [bytes], Available ROM: 2048 [bytes]
0 122 Compilation Started chenillard.c
16 315 Invalid expression chenillard.c
14 402 ; expected, but 'unsigned' found chenillard.c
16 424 '}' expected ';' found chenillard.c
24 371 Specifier needed chenillard.c
24 396 Invalid declarator expected'(' or identifier chenillard.c
36 315 Invalid expression chenillard.c
36 402 ; expected, but 'int' found chenillard.c
36 324 Undeclared identifier 'j' in expression chenillard.c
36 324 Undeclared identifier 'j' in expression chenillard.c
36 425 ')' expected, but ';' found chenillard.c
36 324 Undeclared identifier 'j' in expression chenillard.c
36 402 ; expected, but ')' found chenillard.c
37 424 '}' expected ';' found chenillard.c
40 1503 Result is not defined in function: '' chenillard.c A aucun moment on a une variable Result ??? Même le Result n'apparaît pas dans le source ?
40 312 Internal error '' chenillard.c
0 102 Finished (with errors): 19 avr. 2020, 21:12:40 chenillard.mcppi
Tu as "rebuild" tout le projet car dès fois recompiler simplement ne fonctionne pas, il faut reconstruire le projet (rebuild) ?
ps : chez moi GCC ne trouve aucune erreur sauf la double parenthèse, j'ai juste quelque Warning car il me recommande des parenthèses, mais rien de grave ce n'est pas des erreurs.
Code:
2
3main2.c:41:26: warning: suggest parentheses around comparison in operand of ‘&’ [-Wparentheses] if(ma_variable_16bits & 0x0100 == 1){ ^
je cherche mais je ne vois pas comment faire sur mikroC
Là je ne pourrai pas t'aider, je n'ai pas mikroC.
Peut-être recréer un nouveau projet ?
En tout cas le log montre que c'est pas le bon programme qui est compilé, la ligne en rouge semble dire qu'à la ligne 40 il y a Result qui n'est pas définie. Hors à la ligne 40 du programme il n'y a pas de Result
j'ai récréé un nouveau projet,.. mais ça ne fonctionne toujours pas.
voici les erreurs affichés
0 1139 Available RAM: 208 [bytes], Available ROM: 2048 [bytes]
0 122 Compilation Started Chenillard3.c
16 315 Invalid expression Chenillard3.c
14 402 ; expected, but 'unsigned' found Chenillard3.c
16 424 '}' expected ';' found Chenillard3.c
24 371 Specifier needed Chenillard3.c
24 396 Invalid declarator expected'(' or identifier Chenillard3.c
36 315 Invalid expression Chenillard3.c
36 402 ; expected, but 'int' found Chenillard3.c
36 324 Undeclared identifier 'j' in expression Chenillard3.c
36 324 Undeclared identifier 'j' in expression Chenillard3.c
36 425 ')' expected, but ';' found Chenillard3.c
36 324 Undeclared identifier 'j' in expression Chenillard3.c
36 402 ; expected, but ')' found Chenillard3.c
37 424 '}' expected ';' found Chenillard3.c
40 1503 Result is not defined in function: '' Chenillard3.c
40 312 Internal error '' Chenillard3.c
0 102 Finished (with errors): 20 avr. 2020, 01:03:33 Chenillard3.mcppi
Lorsque tu cliques sur les erreurs est ce que mikroC te montres la ligne de code qui pose problème ?
Si oui montre moi une copie d'écran que je puisse voir quelle erreur correspond à quelle ligne.
Rassure moi, est ce que ton programme, celui d'origine au message n°18 (juste avant que je fusionne tes deux discussions, il compile correctement au moins ? Parce que si on se base sur un code qui ne marche déjà pas, on ne va pas y arriver.
Pour la première erreur essaye unsigned char donnee = 0xAA; pour voir
Ca ne change rien
Pièce jointe 558189
J'ai tout mis tout ce qu'on a rajouté en commentaire, ça fonctionne comme avant
Pièce jointe 558193
