bonjour
bon je viens de lire l'article wikipedia sur l'afficheur
ainsi que celui sur les operateurs bitwise
je comprends que le but de l'exo c'est par exemple :
si j'ai en entree : 2
je dois afficher :
_
_|
|_
j'ai du mal a voir le rapport de comment cela s'articule avec les articles ci dessus.
j'aurais pensé a une solution de manipulation de chaine contenant des '_' et des '|'.
Si tu ne sais pas ce que sont les tables de vérité et comment les utiliser abandonne les opérateur bitwises sinon il te faut écrire l'expression logique de chaque segments grâce à la table de vérité des segments que tu déduis de ton afficheur LCD (selon qu'il soit à cathodes communes ou à anodes communes).
Si tu ne sais pas ce que sont les tables de vérité et comment les utiliser abandonne les opérateur bitwises sinon il te faut écrire l'expression logique de chaque segments grâce à la table de vérité des segments que tu déduis de ton afficheur LCD (selon qu'il soit à cathodes communes ou à anodes communes).
Tu vas trop loin dans ton raisonnement, je pense que ce sera à toi de voir quel type d'afficheur utiliser et comment t'y prendre vu l'énoncé.
Autre chose que ce soit l'un ou l'autre c'est exactement le même programme, sauf qu'au lieu de faire zLCD(variable); tu fais zLCD(~variable); et le tour est joué.
Je crois pas .C'est la dans la table de vérité que tu inverse les bits pas dans la variable même.
Fais un petit carnaugh des deux tables de vérité sors les équations logiques et tu verras la différence c'est juste une inversion de bit.
anode commune : 1 -> éteint , 0 -> allume le ségment.
cathode commune : 0 -> éteint , 1 -> allume le ségment. (c'est l'inverse).
C'est ce que '~' fait.
Ok, je pensais pas que l'on pouvait utiliser `l'opérateur non` directement sur la variable mais qu'à partir des expressions logiques de chaque segments.
bonjour
bon je viens de lire l'article wikipedia sur l'afficheur
ainsi que celui sur les operateurs bitwise
je comprends que le but de l'exo c'est par exemple :
si j'ai en entree : 2
je dois afficher :
_
_|
|_
j'ai du mal a voir le rapport de comment cela s'articule avec les articles ci dessus.
j'aurais pensé a une solution de manipulation de chaine contenant des '_' et des '|'.
si quelqu'un a une idée pour commencer ?
merci
Tu peux tout à fait réaliser un afficheur 7 segments sans utiliser de tables de vérité...
Citation : Darkipod
j'aurais pensé a une solution de manipulation de chaine contenant des '_' et des '|'.
C'est juste ce qu'il faut faire. Ne cherche pas la complication...
#include <stdio.h>
#include <stdlib.h>
void z_lcd(unsigned int n)
{
switch (n) {
case 0 :
printf(" _\n | |\n |_|");printf("\n\n");
break;
case 1 :
printf(" | \n |");printf("\n\n");
break;
case 2 :
printf(" _\n _| \n |_");printf("\n\n");
break;
case 3 :
printf(" _\n _|\n _|");printf("\n\n");
break;
case 4 :
printf(" |_|\n |");printf("\n\n");
break;
case 5 :
printf(" _\n |_\n _|");printf("\n\n");
break;
case 6 :
printf(" _\n |_\n |_|");printf("\n\n");
break;
case 7 :
printf(" _\n |\n |");printf("\n\n");
break;
case 8 :
printf(" _\n |_|\n |_|");printf("\n\n");
break;
case 9 :
printf(" _\n |_|\n _|");printf("\n\n");
break;
}
}
int main(void)
{
int i;
for(i = 0; i <= 9; i++)
z_lcd(i);
return 0;
}
Parce que s'il y a des nombres à afficher, va pas y avoir un problème d'affichage ?
Sinon le truc avec les opérateurs bitwise, je vois pas exactement ce qu'on doit faire.
C'est reprendre les équations réduites des différents segments et faire une fonction à 4 entrées du genre ?
J'arrive à afficher un chiffre au choix par contre je sèche au niveau d'aligner plusieurs chiffres =/ c'est possible en passant par un entier ou il faut utiliser des string absolument??
J'ai utilisé une autre technique, je ne sais pas si c'est la bonne mais j'avais eu un exercice avec les afficheurs 7 segments en cours d'électronique numérique et on a utilisé cette méthode :
//Segment a
if (nombre == 0 || nombre == 2 || nombre == 3 || (nombre >= 5 && nombre <= 9)) {
segment[i][1] = '_';
}
//Segment b
if ((nombre >= 0 && nombre <= 4) || (nombre >= 7 && nombre <= 9)) {
segment[i][5] = '|';
}
//Segment c
if (nombre == 0 || nombre == 1 || (nombre >= 3 && nombre <= 9)) {
segment[i][8] = '|';
}
//Segment d
if (nombre == 0 || nombre == 2 || nombre == 3 || nombre == 5 || nombre == 6 || nombre == 8 || nombre == 9) {
segment[i][7] = '_';
}
//Segment e
if (nombre == 0 || nombre == 2 || nombre == 6 || nombre == 8) {
segment[i][6] = '|';
}
//Segment f
if (nombre == 0 || (nombre >= 4 && nombre <= 6) || nombre == 8 || nombre == 9) {
segment[i][3] = '|';
}
//Segment g
if ((nombre >= 2 && nombre <= 6) || nombre == 8 || nombre == 9) {
segment[i][4] = '_';
}
@darkipod:
Ton code fonctionne bien, mais en fournissant une chaîne à la fonction zLCD... Tu peux essayer en fournissant un entier en paramètre.
Pour les opérateurs bitwises.
Tu peux remarquer que tu stockes tes chiffres dans une grille de dimension 3 x 3, alors que tu n'as que 7 segments.
Tu peux dans un premier temps essayer de stocker la description d'un chiffre sur 7 bits, comme le montre le dernier exemple du lien wikipédia.
Ensuite, il faut que tu saches comment tester l'état d'un bit donné. Les opérateurs bits à bits employés sur des nombres entiers.
@stagiaire en C:
Oui c'est possible, en fournissant un entier(c'est même ce qui est demandé.).
@darkipod:
Ton code fonctionne bien, mais en fournissant une chaîne à la fonction zLCD... Tu peux essayer en fournissant un entier en paramètre.
Pour les opérateurs bitwises.
Tu peux remarquer que tu stockes tes chiffres dans une grille de dimension 3 x 3, alors que tu n'as que 7 segments.
Tu peux dans un premier temps essayer de stocker la description d'un chiffre sur 7 bits, comme le montre le dernier exemple du lien wikipédia.
Ensuite, il faut que tu saches comment tester l'état d'un bit donné. Les opérateurs bits à bits employés sur des nombres entiers.
itoa, que te conseille Adronéus, est une fonction qui convertit un entier en chaîne de caractère.
Effectivement, cela te permettrait de conserver ta fonction, mais en recevant un int que tu convertirait en chaîne.
Pour ma part, je pense qu'il est plus intéressant pour toi, de vraiment travailler sur un entier(maintenant que tu sait comment faire avec une chaîne).
Je vois pas trop comment utiliser le bitwise ici étant donné que c'est plutôt en base 10 qu'on devrait travailler ... c'est possible d'utiliser le n << 1 avec les puissances de 10?
Je vois pas trop comment utiliser le bitwise ici étant donné que c'est plutôt en base 10 qu'on devrait travailler ... c'est possible d'utiliser le n << 1 avec les puissances de 10?
As tu regardé le lien wikipédia sur les afficheurs 7 segments.
La base, osef Ce n'est pas ton nombre que tu traites avec les opérateurs bitwises, ce sont les segments.
Ici, c'est juste une manière de représenter les segments en mémoires. Par exemple, à 1 segment correspond à bit.
Je précise encore une fois : essayez déjà de faire l'exo de manière simple, avec vos connaissances du moment. Si ça roule, regardez plus loin, mais pas avant
Je vais finir par regretter d'avoir parlé d'opérateurs bitwise .
Ah ouais je vois ce que tu veux dire. Mais bon j'arrive à afficher tous les chiffres de 0 à 9 pour le moment moi mon problème c'est de prendre un chiffre après l'autre de mon entier. Je vais chercher du côté des divisions et des modulos mais pour le moment c'est assez flou pour moi
EDIT : Oh je crois que j'ai compris pourquoi tu parles d'opérateurs bitwise en fait mais je suis pas sur. Faudrait qu'on traduise ceci
Citation : Wikipedia
En notant les Entrée 1, 2, 3, 4 du tableau ci-dessus respectivement i1, i2, i3 et i4, les équations des segments(pour afficher les nombres de 0 à F) sont:
* a = (not(i1) and i3) or (i1 and not(i4)) or (i2 and i3) or not(i2 or i4) or (i1 and not(i2) and not(i3))or (not(i1) and i2 and i4)
* b = not(i1 or i2) or not(i2 or i3) or not(i2 or i4) or (not(i1) and not(i3 xor i4)) or (i1 and not(i3) and i4)
* c = (i1 xor i2) or (not(i3) and i4) or (not(i3 xor i4) and not(i2))
* d = (i1 and not(i3)) or not(i1 or i2 or i4) or (i2 and (i3 xor i4)) or (not(i2) and i3 and i4)
* e = not(i2 or i4) or (i3 and not(i4)) or (i1 and i2) or (i1 and i3)
* f = (i1 and not(i2)) or not(i3 or i4) or (not(i3) and (i1 xor i2)) or (i1 and i3) or (i2 and not(i4))
* g = (i3 and (i1 or not(i2) or not(i4))) or (i1 and i4) or (not(i3) and (i1 xor i2))
en code C c'est ça? Mais bon je vois plein de difficultés qui se dressent sur mon chemin ><"
Si tu arrives à afficher un chiffre, c'est un bon début, après plusieurs solutions :
<liste>
-Tu travaille sur une chaine(comme darkipod) et là c'est très simple.
-Tu travaille sur un entier, le plus simple est de le décomposer par la droite.
le (petit)challenge avec cette solution, c'est l'affichage.
Astuce : Pourquoi ne pas passer par un tableau?
Le passage que tu cites de l'article wikipédia, concerne le stockage des chiffres sur 4 bits, et ce n'est pas le plus simple... Je te conseille, lorsque tu auras réussi avec ta méthode, de plutôt t'intéresser au stockage sur 8 bits(7 en fait).
Citation : darkipod
Citation : gurneyH
Je vais finir par regretter d'avoir parlé d'opérateurs bitwise .
que neni, ça mets du piment à l'exo
J'ai également l'impression que ça vous embrouille pas mal.
Merci j'utilise un tableau[i][j] je suis entrain d'essayer de trouver l'astuce au niveau de l'affichage après je verrai cette histoire de bits
C'est bon
Voilà ma solution
Main.c
#include <stdio.h>
#include <stdlib.h>
#include "main.h"
void afficherSegments(int nombre);
int main()
{
int chiffre = 0;
printf("Afficheur 7 segments\n\nEntrez un chiffre : ");
scanf("%d", &chiffre);
afficherSegments(chiffre);
return 0;
}
void afficherSegments(int chiffre)
{
char segment[100][9] = {{0}};
int i = 0, j = 0, nombre = 0, tour = 0, nombreChiffres = 0;
for(;chiffre > 0; chiffre /= 10) {
nombre = chiffre % 10;
nombreChiffres++;
i++;
//Segment a
if (nombre == 0 || nombre == 2 || nombre == 3 || (nombre >= 5 && nombre <= 9)) {
segment[i][1] = '_';
}
//Segment b
if ((nombre >= 0 && nombre <= 4) || (nombre >= 7 && nombre <= 9)) {
segment[i][5] = '|';
}
//Segment c
if (nombre == 0 || nombre == 1 || (nombre >= 3 && nombre <= 9)) {
segment[i][8] = '|';
}
//Segment d
if (nombre == 0 || nombre == 2 || nombre == 3 || nombre == 5 || nombre == 6 || nombre == 8 || nombre == 9) {
segment[i][7] = '_';
}
//Segment e
if (nombre == 0 || nombre == 2 || nombre == 6 || nombre == 8) {
segment[i][6] = '|';
}
//Segment f
if (nombre == 0 || (nombre >= 4 && nombre <= 6) || nombre == 8 || nombre == 9) {
segment[i][3] = '|';
}
//Segment g
if ((nombre >= 2 && nombre <= 6) || nombre == 8 || nombre == 9) {
segment[i][4] = '_';
}
}
for (tour = 0; tour < 3; tour++) {
for (i = nombreChiffres; i >= 0; i--) {
for (j = 0; j < 3; j++) {
printf("%c", segment[i][j + (3 * tour)]);
switch (j % 3) {
case 2:
printf(" ");
break;
default:
break;
}
}
}
printf("\n");
}
}
Main.h
#ifndef MAIN_H
#define MAIN_H
typedef struct Afficheur Afficheur;
struct Afficheur
{
int x;
int y;
};
#endif //MAIN_H
Il y a surement des améliorations possible (surtout au niveau de nombreChiffres et i, on devrait pouvoir les "fusionner" mais j'ai rien trouvé de plus simple vite fait) mais ça marche et je suis content xD
#include <stdio.h>
#include <stdlib.h>
#define and &&
#define or ||
#define xor ^
#define not ~
void fonction(int i1,int i2,int i3,int i4)
{
int a,b,c,d,e,f,g;
a = (not(i1) and i3) or (i1 and not(i4)) or (i2 and i3) or not(i2 or i4) or (i1 and not(i2) and not(i3))or (not(i1) and i2 and i4);
b = not(i1 or i2) or not(i2 or i3) or not(i2 or i4) or (not(i1) and not(i3 xor i4)) or (i1 and not(i3) and i4);
c = (i1 xor i2) or (not(i3) and i4) or (not(i3 xor i4) and not(i2));
d = (i1 and not(i3)) or not(i1 or i2 or i4) or (i2 and (i3 xor i4)) or (not(i2) and i3 and i4);
e = not(i2 or i4) or (i3 and not(i4)) or (i1 and i2) or (i1 and i3);
f = (i1 and not(i2)) or not(i3 or i4) or (not(i3) and (i1 xor i2)) or (i1 and i3) or (i2 and not(i4));
g = (i3 and (i1 or not(i2) or not(i4))) or (i1 and i4) or (not(i3) and (i1 xor i2));
printf("%d %d %d %d %d %d %d \n",a,b,c,d,e,f,g);
}
void afficherSegments(int nombre);
int main()
{
fonction(0,0,0,1);
return 0;
}
j'obtiens pas ce que je veux puisque je devrais avoir que les segments B et C a 1 ce qui correspond à 0001 en binaire soit 1 en base 10. Or j'ai a b c d e f g tous à 1?
Les formules sur wikipedia sont elles fausses ? parce que je ne sais pas les trouvées
Ne pas confondre les opérateurs bitwise et les opérateurs logiques !
Le && est un opérateur logique, ainsi que le ||. Le & est un opérateur au même titre que le |.
De ce fait 2 && 5 ne donnera pas la même chose que 2 & 5 ; dans le premier cas on teste si 2 et 5 sont différents de 0, tandis que dans le deuxième cas on teste (en binaire) 11 ET 101 (qui vaudra 0).
@Stagiaire en C : Non, tu n'as pas utilisé les opérateurs bitwise.
A titre informatif les opérateurs bitwise sont :
& /* ET */
| /* OU */
^ /* OU exclusif */
~ /* NON */
<< /* Décalage à gauche */
>> /* Décalage à droite */
Sinon pour les bitwise pour récupérer l'état des bits ont peut utiliser ces deux fonctions (la première était un cas spécifique de la seconde qui est générale).
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Objectif Zéro Bug - le test logiciel professionnel | L'électronique de zéro | Tableaux & pointeurs | Pointeurs sur fonctions | Lecture/écriture binaire
Objectif Zéro Bug - le test logiciel professionnel | L'électronique de zéro | Tableaux & pointeurs | Pointeurs sur fonctions | Lecture/écriture binaire