Partage
  • Partager sur Facebook
  • Partager sur Twitter

zLCD

zSolutions

    3 mars 2010 à 4:20:48

    Salut,

    Vous pouvez poster ici, vos solutions et questions concernant le premier exercice du mois de mars..

    Merci :)
    • Partager sur Facebook
    • Partager sur Twitter
    Zeste de Savoir, le site qui en a dans le citron !
      3 mars 2010 à 8:44:04

      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
      • Partager sur Facebook
      • Partager sur Twitter
        3 mars 2010 à 15:38:52

        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).
        • Partager sur Facebook
        • Partager sur Twitter
          Staff 3 mars 2010 à 16:30:31

          Citation : Lithrein

          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).



          :lol: 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é.
          • Partager sur Facebook
          • Partager sur Twitter
            3 mars 2010 à 16:39:17

            Citation : uknow

            <citation rid="4721848">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.
            • Partager sur Facebook
            • Partager sur Twitter
              Staff 3 mars 2010 à 16:43:27

              Citation : Lithrein


              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.
              • Partager sur Facebook
              • Partager sur Twitter
                3 mars 2010 à 16:58:30

                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.
                • Partager sur Facebook
                • Partager sur Twitter
                  3 mars 2010 à 17:03:42

                  Citation : darkipod

                  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... ;)
                  • Partager sur Facebook
                  • Partager sur Twitter
                  Zeste de Savoir, le site qui en a dans le citron !
                    3 mars 2010 à 17:34:09

                    je vais le faire comme je me le sents... :-°
                    • Partager sur Facebook
                    • Partager sur Twitter
                      3 mars 2010 à 18:05:34

                      Est ce qu'il faut faire ça ?
                      #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 ?
                      void z_lcd(int, int, int, int);
                      
                      /* ... */
                      
                      int main(void)
                      {
                              z_lcd(1,1,0,1);
                              return 0;
                      }
                      
                      • Partager sur Facebook
                      • Partager sur Twitter
                        4 mars 2010 à 3:55:28

                        La fonction zLCD doit être capable d'afficher un nombre entier.

                        Citation : Colb seton


                        Sinon le truc avec les opérateurs bitwise, je vois pas exactement ce qu'on doit faire.


                        Tu devrais voir comment tu peux coder cette fonction avec les connaissance du tuto C du site.

                        Une fois fait, tu auras toujours le temps de t'occuper de la partie "avancée".

                        Ne vous compliquez pas la vie, cet exercice est simple... :-°

                        J'ai donné la piste des opérateurs bitwise pour ceux qui le trouvent trop simple, pas pour embrouiller les autres. ;)
                        • Partager sur Facebook
                        • Partager sur Twitter
                        Zeste de Savoir, le site qui en a dans le citron !
                          4 mars 2010 à 8:14:32

                          Bonjour, je vous propose une solution que voici que voila :
                          #include <stdio.h>
                          #include <stdlib.h>
                          
                          
                          char *a1=" _     _  _     _  _  _  _  _ ";
                          char *a2="| | |  _| _||_||_ |_   ||_||_|";
                          char *a3="|_| | |_  _|  | _||_|  ||_| _|";
                          
                          int len (char *ch)
                          {
                              int i=0;
                              for(;*ch != '\0';ch++)
                              {
                                  i++;
                              }
                              return i;
                          }
                          void extract(int ordre,int pos,char *L1,char *L2,char*L3)
                          {
                              int i=0;
                              int j=pos;
                              for(i=(ordre*3);i<((ordre*3)+3);i++)
                              {
                                  L1[j]=a1[i];
                                  L2[j]=a2[i];
                                  L3[j]=a3[i];
                                  j++;
                              }
                              L1[j]='\0';
                              L2[j]='\0';
                              L3[j]='\0';
                          
                          }
                          
                          void affiche_ligne(char *ch,int longueur)
                          {
                              int i,x,position;
                              // une ligne = 80 caracteres, soit 80/3=26 chiffres
                              char L1[80]="";
                              char L2[80]="";
                              char L3[80]="";
                              position=0;
                              for (i=0;i<longueur;i++)
                              {
                                  x=ch[i]-'0';
                                   //aucune securite si je rentres une lettre suffit de rajouter une condition sur 0<=x<=9
                                  extract(x,position,L1,L2,L3);
                                  position=position+3;//un grand caractere = 3 position
                              }
                              printf("%s\n%s\n%s\n",L1,L2,L3);
                          }
                          
                          int main(void)
                          {
                              char *ch="123456789012345634";
                              if (len(ch)<27)
                              {
                                  affiche_ligne(ch,len(ch));
                              }
                              else
                              {
                                  printf("Desole maximum par ligne 26 caracteres !");
                              }
                              return 0;
                          }
                          

                          Qu'en pensez vous ? J'aimerais bien aller de l'avant mais une âme pour me guider besoin j'aurais :lol:

                          Citation : gurneyH

                          J'ai donné la piste des opérateurs bitwise pour ceux qui le trouvent trop simple, pas pour embrouiller les autres.


                          une petite explication sur le sujet que je puisse au moins faire quelque chose!!
                          merci
                          • Partager sur Facebook
                          • Partager sur Twitter
                            4 mars 2010 à 9:24:59

                            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 :



                            Image utilisateur

                            //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] = '_';
                                }
                            
                            • Partager sur Facebook
                            • Partager sur Twitter
                              4 mars 2010 à 17:19:31

                              @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é.). ;)

                              • Partager sur Facebook
                              • Partager sur Twitter
                              Zeste de Savoir, le site qui en a dans le citron !
                                4 mars 2010 à 17:39:15

                                @darkipod : Si t'as pas envie de t'embeter, fais un my_itoa :) ca evitera que tu revoies tout ton algo
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  5 mars 2010 à 8:10:26

                                  Citation : GurneyH

                                  @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.


                                  ok je vais y reflechir....... :-°

                                  Citation : androneus

                                  fais un my_itoa


                                  :euh: ?
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    5 mars 2010 à 8:27:43

                                    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). ;)
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    Zeste de Savoir, le site qui en a dans le citron !
                                      5 mars 2010 à 8:54:48

                                      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?
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        5 mars 2010 à 9:04:37

                                        Citation : Stagiaire en C

                                        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 :'( .

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        Zeste de Savoir, le site qui en a dans le citron !
                                          5 mars 2010 à 9:07:30

                                          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 ><"
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            5 mars 2010 à 9:13:59

                                            Citation : gurneyH

                                            Je vais finir par regretter d'avoir parlé d'opérateurs bitwise .


                                            que neni, ça mets du piment à l'exo :D
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              5 mars 2010 à 9:20:05

                                              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 :D


                                              J'ai également l'impression que ça vous embrouille pas mal. :p
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                              Zeste de Savoir, le site qui en a dans le citron !
                                                5 mars 2010 à 9:31:33

                                                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 :D

                                                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


                                                EDIT : en fait là j'ai fait du bitwise non? Oo
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  5 mars 2010 à 17:20:33

                                                  bon j'ai fait un test :
                                                  #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
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    5 mars 2010 à 17:58:47

                                                    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 */
                                                    

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      5 mars 2010 à 18:27:28

                                                      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).

                                                      typedef unsigned int uint32;
                                                      
                                                      uint32 /* Les positions commencent à 0 */
                                                      lire_bit (uint32 value, uint32 position) {
                                                          return (value >> position) & 01;
                                                      }
                                                      
                                                      uint32
                                                      lire_bits (uint32 value, uint32 position, uint32 nb) {
                                                          return (value >> (position-nb+1)) & ~(~0 << nb);
                                                      }
                                                      
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        5 mars 2010 à 18:33:58

                                                        Tes 2 fonctions sont fausses. :-°
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          5 mars 2010 à 19:06:41

                                                          Citation : Pouet_forever

                                                          Tes 2 fonctions sont fausses. :-°


                                                          Je te garantie le contraire.
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            5 mars 2010 à 19:37:09

                                                            Citation : Pouet_forever

                                                            Tes 2 fonctions sont fausses. :-°



                                                            J'ai juste regarder rapidement et
                                                            lire_bit (uint32 value, uint32 position) {
                                                                return (value >> position) & 01;
                                                            }
                                                            

                                                            au moins, pour moi, est correcte...

                                                            Tu te décales sur le bit de poids faible et tu teste l'état de ce bit...
                                                            Ou est le problème? o_O
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                            Zeste de Savoir, le site qui en a dans le citron !
                                                              5 mars 2010 à 19:39:22

                                                              Citation : Lithrein

                                                              Je te garantie le contraire.


                                                              Je te garantie que tu as édité. :-°
                                                              La deuxième est quand même incorrecte. ;)

                                                              @GurneyH : Quand j'ai posté c'était pas ces fonctions qui étaient affichées. :-°
                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              zLCD

                                                              × 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.
                                                              • Editeur
                                                              • Markdown