IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Embarqué Discussion :

Programmation d'un processeur avec son afficheur


Sujet :

Embarqué

  1. #1
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut Programmation d'un processeur avec son afficheur
    Bonjour,

    je suis actuellement en cours de programmation d'un microcontroleur pic32mx795f512l afin de gérer des batteries lithium et j'ai donc besoin non seulement de récupérer leur état de charge via l'échange avec un composants dont le rôle est de mesurer le passage du courant et en déduit donc ce qui reste.

    Pour ce faire, je dois récupérer l'info et l'afficher sur un afficheur 128/64 pixel, j'affiche donc le symbole d'une batterie vide sur mon afficheur par cette fonction

    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
    
    #define Image_batterie_vide_LEN  134
    
    unsigned char Image_batterie_vide[Image_batterie_vide_LEN] =
    {
       22, 48,
      255,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
        1,  1,  1,  1,  1,255,255,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,255,255,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,255,255,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,255,255,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,255,255,128,
      128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
      128,128,128,255
    };
    
    
    
    void picture(uint16_t column,uint16_t page, const uint8_t *pic_adress)  
    {
    	uint8_t c,p;
    	unsigned int byte_cnt = 2;
    	uint8_t width, page_cnt;
    		
    	width = pic_adress[0];
    	page_cnt =(pic_adress[1] + 7) / 8; //height in pages, add 7 and divide by 8 for getting the used pages (byte boundaries)
    	     
      //if(width + column > 128)	width = 128 - column; // ecran postion normal
      if(width + column > 132)	width = 132 - column;  // ecran inversé
      if(page_cnt + page > 8)page_cnt = 8 - page;
    
    	for(p=0; p<page_cnt; p++)
    	{
    		position(column, page + p);
            
            
    		for(c=0; c<width; c++) // écran normal
                send_data(pic_adress[byte_cnt++]);
    	}
    }
    
    
    picture(10,2,Image_batterie_vide);
    ça c'est donc ok et sa s'affiche bien

    ce que je souhaite faire, est de faire varier le remplissage en fonction du niveau de charge que je récupèrerais, j'ai donc commencer une fonction pour le faire, mais évidemment je n'arrive pas à remplir mon tableau comme je le souhaite puisqu'il reste à zéro (:

    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
    51
    52
    53
    54
    55
    56
    void niveaux(uint8_t niveau_bat, uint8_t *tab_gauge)
    {
    uint16_t j,k,i,l;
    uint8_t nbr_ligne;
    uint16_t b;
    
    j=132;
    k=0;
    i=0;
    l=0;
    b=1056;
    
    nbr_ligne=(niveau_bat*b)/100;
    
    essai=40;
        for(l=0 ; l<6 ; l++)
        {
        
                        for (i=0; i < 23; i++) // sur 22 données du tableau
                        {
                        
                        j=j-i ;
                        
    
                              for (k=0 ; k < 8; k++)                        
                              {
                                  
                              
                                     if(Image_batterie_vide[j]==tab_pixel[k]) 
                                     {
                                     
                                      
                                      
                                           if(Image_batterie_vide[j]< 256)
                                                   {
                                                   essai=52;
                                                    tab_gauge[j]=Image_batterie_vide[j];//+ puissance(2,(k-1));
                                                    //tab_gauge[j]=0;
                                                    
                                                   } 
                                                   
                                      k=11;                                              
                                     }  
                                 
                              nbr_ligne--;
    						  if (nbr_ligne < 0){ k=8; i=23; l=6;}; 
                              }
                           
                        
                        }
    
        }           
    	 
    	 
    	 
    }
    le remplissage par ligne ce trouve sur 22 chiffres du tableau de 132, c'est 22 chiffre peuvent prendre les valeurs suivante en fonction du nombre de ligne

    1er ligne 128
    2ième ligne 192
    3ième ligne 224
    4ième ligne 240
    5ième ligne 248
    6ième ligne 252
    7ième ligne 254
    8ième ligne 255

    pourriez vous m'orienter ou me dire mes erreur s'il vous plait ?
    Merci pour votre aides

  2. #2
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    Bonjour et mes meilleurs vœux à tous,

    Me serais-je trompé de catégorie ? n'ayant pas de retours.

  3. #3
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Ancien développeur matériel électronique (Hard/Soft)
    Inscrit en
    avril 2002
    Messages
    2 952
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Ancien développeur matériel électronique (Hard/Soft)
    Secteur : Service public

    Informations forums :
    Inscription : avril 2002
    Messages : 2 952
    Points : 10 636
    Points
    10 636
    Par défaut
    Bonjour et meilleurs voeux également,
    Peux tu montrer ce que c'est sensé faire ? (un dessin, une image)

    C'est un problème algorithmique, le mieux serait que je transferts ton message sur le forum "langage C" mais avant je voudrai voir s'ils pourront modéliser le problème en faisant abstraction du micro. Visiblement je dirai que oui car je ne vois aucune référence à au micro dans ton code.

    Il faut qu'ils puissent transformer le picture(10,2,Image_batterie_vide); par un printf(...); sur une console et ensuite ils pourront te répondre quant à ce que doit contenir void niveaux(uint8_t niveau_bat, uint8_t *tab_gauge)

    Mais il faut une image de ce que ça doit faire à l'écran car pour être franc, je ne le vois pas moi même, donc impossible de trouver ce qui ne va pas dans ta fonction.

    A+
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  4. #4
    Membre éprouvé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 346
    Points : 1 211
    Points
    1 211
    Par défaut
    Bonjour,

    Il est étrange que le tableau qui représente un espace en 2 D soit à une seule dimension. D'où la question sur la taille de l'image de la batterie : largeur et hauteur.

    Cela permettrait de comprendre ou de corriger des incohérences comme par exemple :

    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    for (i=0; i < 23; i++) // sur 22 données du tableau

    i variera de 0 à 22 soit 23 données du tableau et non 22.

    En outre il doit certainement exister une bibliothèque graphique pour piloter simplement l'affichage ?

    Salutations
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  5. #5
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    Bonjour et merci de votre temps,

    Désolé d'avoir tardé à réagir, je vais essayé d'être plus explicite.

    En fait, je pilote un afficheur LCD graphique de 128/64 pixels comme celui-ci, pour l'instant ce sont des tests, ce qui est affiché ne représente pas sont fonctionnement car plus le pourcentage est élevé plus la batterie ce remplie.
    Nom : 20201204_093400.jpg
Affichages : 76
Taille : 573,3 Ko

    chacune des jauges sont indépendante et font 22/48 pixels représenté par le tableau d'une batterie vide "Image_batterie_vide[Image_batterie_vide_LEN]"
    l'idée est donc de partir de l'image d'une batterie vide et qu'elle ce remplisse (ou ce vide) au fur et à mesure de l'évolution d'une variable dont la valeur évolue de 0 à 100%.

    Je viens donc renseigner ce tableau :
    unsigned char Image_batterie1[134]; à l'aide de celui d'une batterie vide.

    sachant que les valeurs du tableau change de la dernière valeur à la première, par packet de 22 chiffres de tel sorte :

    D'ou ce tableau uint8_t tab_pixel[8]={255,254,252,248,240,224,192,128};

    la première ligne les valeurs des 22 derniers doivent prendre la valeurs de 128.
    la deuxième ligne les valeurs des 22 derniers doivent prendre la valeurs de 192.
    la troisième ligne les valeurs des 22 derniers doivent prendre la valeurs de 224.
    la 4ième ligne les valeurs des 22 derniers doivent prendre la valeurs de 240.
    la 5ième ligne les valeurs des 22 derniers doivent prendre la valeurs de 248.
    la 6ième ligne les valeurs des 22 derniers doivent prendre la valeurs de 252.
    la 7ième ligne les valeurs des 22 derniers doivent prendre la valeurs de 254.
    la 8ième ligne les valeurs des 22 derniers doivent prendre la valeurs de 255.

    la 9ième ligne les valeurs des 22 avant derniers doivent prendre la valeurs de 128.
    la 10ième ligne les valeurs des 22 avant derniers doivent prendre la valeurs de 192.
    la 11ième ligne les valeurs des 22 avant derniers doivent prendre la valeurs de 224.
    la 12ième ligne les valeurs des 22 avant derniers doivent prendre la valeurs de 240.
    la 13ième ligne les valeurs des 22 avant derniers doivent prendre la valeurs de 248.
    la 14ième ligne les valeurs des 22 avant derniers doivent prendre la valeurs de 252.
    la 15ième ligne les valeurs des 22 avant derniers doivent prendre la valeurs de 254.
    la 16ième ligne les valeurs des 22 avant derniers doivent prendre la valeurs de 255.

    -
    -
    -

    Une fois le tableau renseigné de ces nouvelles valeurs je viens l'afficher aussitôt avec la fonction d'affichage :
    picture(0,0, Image_batterie1);

    Voila comment pourrais ce faire la fonctionnalité imaginé.
    Mes notion de programmation étant limité j'ai pensé au première abord à définir les opérations ci-dessus.

    actuellement, mon tableau ne ce rempli pas et donc reste à zéro, il faut que je vois ce qui ce passe.

    J'espère avoir été plus claire.
    Merci pour vos éclairage

  6. #6
    Membre éprouvé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 346
    Points : 1 211
    Points
    1 211
    Par défaut Imgage à plat ?
    Bonjour,

    N'y a t'il pas un problème avec 1056 ? Le nombre de lignes doit être <= 48 (taille de l'image en hauteur) mais cela implique que (niveau_bat*1056)/100 <= 48 c'est à dire que niveau_bat <= 4800 /1056 soit niveau_bat < 5. Cela ne fait que 5 valeurs différentes de 0 à 4 (pour un uint8_t).

    En réagençant l'image de la pile vide on obtient ceci :
    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    unsigned char Image_batterie_vide[Image_batterie_vide_LEN] =
    {
       22, 48,
      255,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,255,
      255,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,255,
      255,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,255,
      255,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,255,
      255,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,255,
      255,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,255
    };
    Si on considère que la première ligne du tableau est le bas de l'accumulateur, pour remplir la batterie (non testé) :
    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    void DoImgLevel(uint8_t niveau_bat, uint8_t *tab_gauge)
       int ix, msk;
       uint8_t *pEmpty = pic_adress + 3;             // Premier octet intérieur 0:W, 1:H, 2:bord,...
       uint8_t *pGauge = tab_gauge  + 3;
       n = ???;
       if(n > 47) n = 47;                            // niveau de la batterie projeté entre 0 et 47
       int ndiv8 = n >> 3;                           // Niveau = combien d'octets pleins en vertical
       for (int y8 = 0; y8 < 6; ++y) {               // De 8 points en 8 points verticalement
          if (y < ndiv8) msk = 255 else if (y > ndiv8) msk = 0; else msk = (2 << (n & 7)) - 1;
          for (int ix = 20; ix; --ix, ++pGauge, ++pEmpty) 
             pGauge^ = uint8_t(msk) | pEmpty^;
          pGauge += 2;                               // Sauter le bord droit puis le bord
          pEmpty += 2;                               // gauche de la ligne suivante.
       }
    L'orientation des données dans le tableau ne simplifie pas le travail.
    Il serait préférable de définir un type _ImgBatt qui serait commun aux deux images (vide et en charge). Mais vue la simplicité de la batterie vide, je crois que l'on pourrait s'en passer (en ajoutant les bords à la volée).

    Salutations
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  7. #7
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    Bonjour Guesset,

    Merci de ton retour, je vais prendre le temps de me poser sur ton code dès maintenant, a chaque fois que je pense me remettre sur les jauges d'affichage je traverse d'autre problèmes hardware notamment à devoir résoudre ce qui explique ma réactivité (:
    Les 1056=22x48 représente la totalités des données du tableau jauge à remplir en fonction de l'état et donc retour de ma variable compris entre 0 à 100.

    que veux-tu dire par "Il serait préférable de définir un type _ImgBatt qui serait commun aux deux images (vide et en charge). "
    Je raisonnai en reprenant l'image de ma batterie vide que je remplissais régulièrement en fonction de l'état de ma variable, comme ça je garde les bords et j'ai donc juste qu'a incrémenter.

    Effectivement, la façon dont ta réagencer le tableau est plus parlant, c'est là ou l'on voit de vrai codeur (: réflexe pas encore acquis.

    Merci

  8. #8
    Membre éprouvé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 346
    Points : 1 211
    Points
    1 211
    Par défaut Bonnes habitudes ?
    Bonjour David,

    Citation Envoyé par davidif Voir le message
    Que veux-tu dire par "Il serait préférable de définir un type _ImgBatt qui serait commun aux deux images (vide et en charge)."
    C'est juste une sécurité. Actuellement les 2 images batterie ne sont pas liées et rien n'empêche d'avoir une définition différente pour chacune avec les problèmes que cela peut engendrer. En disant qu'elles sont d'un même type, elles ne peuvent plus être différentes. De plus, si un jour il était utile de changer la taille de cette image, il suffirait de la modifier dans le type _ImgBatt (ou n'importe quel nom de type selon la convention adoptée TImgBatt, FImgBatt ...).

    Par ailleurs, mettre des données de nature différente dans un même tableau (largeur, hauteur, pixels) ne facilite ni la programation ni la lisibilité. Une structure (struct) serait plus appropriée.

    Salutations
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  9. #9
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    Bonjour Guesset et merci pour ton aide.

    Comme tu peux t'en douter, quelques notions me manque pour comprendre tout ton code, mais je m'en suis inspiré en renforçant également l'aspect pointeur que je ne maitrise pas totalement pour avoir pondu ce code (: :

    Code C++ : 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
    void niveau (char niveau_bat, *tab_gauge)
    {
    uint8_t *ptab=&tab_gauge[134];
    uint8_t *pemptyjauge=&Image_batterie_vide[134];
    uint8_t nbr_data;//=niveau_bat/2;  //valeur du soc compris entre 0 et 50 
    uint8_t tab_gauge[0]=22;
    uint8_t tab_gauge[1]=48;
    uint8_t i,j,k,l;
     
    	for(l=2 ; l>134 ; l++) {tab_gauge[l]=0;}
     
    nbr_data = niveau_bat * 1,32;  //rendre en proportion du tableau 
    tab_pixel=[0,128,192,224,240,248,252,254,255];
    //tab_pixel=[255,254,252,248,240,224,192,128,0]
     
     
     
    		for(k=0; k>6 ; k++)
    		{
     
    				for(i=22; i==0 ; i--) // par ligne de 22 
    				{
     
    						for(j=0 ;j>9;j++) // scan du tableau de valeur de données possible 
    						{
    							if(*pemptyjauge==tab_pixel[j]){ *ptab=tab_pixel[j+1]; j=9;}
    							if(*pemptyjauge>255) *pemptyjauge=255;
     
    						}
     
    					pemptyjauge--;	
    					ptab--;
    					nbr_data--;
    					if(nbr_data==0) {i=0; k=6;}
    				}
     
    		}
     
     
    }

    j'assai de faire au mieux par rapport au besoin et de mon délais notamment ...
    ça te parait un peut faisable comme ça ?
    Dans l'idée je prend l'entièreté du tableau gauge vide que j'incrémente simplement en fonction du niveau sans m'arrêter aux bord.

  10. #10
    Membre éprouvé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 346
    Points : 1 211
    Points
    1 211
    Par défaut
    Bonjour,

    Je me suis aperçu que dans mon code j'ai utilisé une notation Pascal pour déférencer les pointeurs. Il convient de remplacer tous les p^ par *p. Mille excuses.
    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    void DoImgLevel(uint8_t niveau_bat, uint8_t *tab_gauge)
       int ix, msk;
       uint8_t *pEmpty = pic_adress + 3;             // Premier octet intérieur 0:W, 1:H, 2:bord,...
       uint8_t *pGauge = tab_gauge  + 3;
       n = ???;
       if(n > 47) n = 47;                            // niveau de la batterie projeté entre 0 et 47
       int ndiv8 = n >> 3;                           // Niveau = combien d'octets pleins en vertical
       for (int y8 = 0; y8 < 6; ++y) {               // De 8 points en 8 points verticalement
          if (y < ndiv8) msk = 255 else if (y > ndiv8) msk = 0; else msk = (2 << (n & 7)) - 1;
          for (int ix = 20; ix; --ix, ++pGauge, ++pEmpty) 
             *pGauge = uint8_t(msk) | *pEmpty;
          pGauge += 2;                               // Sauter le bord droit puis le bord
          pEmpty += 2;                               // gauche de la ligne suivante.
       }

    Je n'ai pas tout regardé (les grandes indentations et les nombreux sauts de ligne rendent la lisibilité difficile surtout sous navigateur) mais déjà la ligne 21 est fausse car la boucle ne sera jamais exécutée :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    for(i=22; i==0 ; i--) // par ligne de 22
    En fait toutes les boucles sont erronées. La boucle est exécutée si l'expression du milieu est vrai. Pour corriger par exemple le code précédent il suffit d'écrire :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    for(i=22; i!=0 ; i--) // par ligne de 22
    ou (habitude plus sûre) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    for(i=22; i > 0 ; i--) // par ligne de 22
    Il y a un mélange entre l'usage des pointeurs et celui des tableaux (exemple ligne 26). Ce n'est pas interdit mais cela facilite les erreurs (ligne 26, on veut vraiment toujours travailler sur les mêmes octets de 1 à 8 ?). La sortie par j = 9 fonctionne bien (une fois la correction de boucle faite) mais il existe aussi l'instruction break qui est faite pour ça.

    Pour les indentations, il est préférable d'éviter les caractères tab et préférer des espaces car un tab ne correspond pas à un nombre maitrisé d'espaces (cela peut se paramétrer dans les préférences de l'éditeur).

    Bonne continuation.
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  11. #11
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    Oui je me suis aperçu des erreur des for lorsque j'ai vu que je pouvais toujours attendre que ça rentre (:

  12. #12
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    bon j'avance doucement, peut-être trop doucement

    Code C++ : 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
    void niveaux(uint8_t niveau_bat,unsigned char *tab_gauge)
    {
     
    uint8_t nbr_data;//=niveau_bat/2;  //valeur du soc compris entre 0 et 50 
    uint8_t i,j,k,l;
    uint8_t size=133;
     
    for(l=2 ; l>size ; l++) {tab_gauge[l]=0;}
    //i=j=k=l=0;
     
    tab_gauge[0]=22;
    tab_gauge[1]=48;
     
    var=nbr_data = niveau_bat*1.32;  //rendre en proportion du tableau 
    unsigned char tab_pixel[]={0,128,192,224,240,248,252,254,255};
     
    		for(k=0; k < 6 ; k++)
    		{
     
                    for(l=0;l<8; l++)
                    {
                            for(i=0; i<23 ; i++) // par ligne de 22 
                            {
     
                                    for(j=0 ;j<9;j++) // scan du tableau de valeur de données possible 
                                    {
     
                                        if(Image_batterie_vide[size]==tab_pixel[j]){ tab_gauge[size]=tab_pixel[j+1]; j=9;}
                                        if(tab_gauge[size]>=255)tab_gauge[size]=255;	
     
                                    }
     
                            //nbr_data--;   
                            size--;        
                            }
     
                    size=size+i;
                    //nbr_data--;
                    if(nbr_data==0) {i=0; k=6;}       
                    }            
    		size=size-22;
    		}
     
    }

    Nom : 20210110_181246.jpg
Affichages : 47
Taille : 1,73 Mo

  13. #13
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    J'ai un peut de mal à comprendre ce qui ce passe, je fais des saut alors que je repasse théoriquement 8x sur chacune des 22 données tout en augmentant leur valeurs ... ce qui devrait ajouter des lignes supplémentaires
    me trompe-je ??? évidemment plus probable (:

  14. #14
    Membre éprouvé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 346
    Points : 1 211
    Points
    1 211
    Par défaut ???
    Bonjour,

    Je ne comprends pas trop le code.

    Il y a toujours l'erreur sur le nombre de points par ligne dans la boucle : 22 va de 0 à 21 donc la comparaison doit être < 22 et non < 23.

    Le scan du tableau est étrange :
    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    if(Image_batterie_vide[size] == tab_pixel[j]) {  tab_gauge[size] = tab_pixel[j+1]; ...
    Il ne dépend pas du niveau et j+1 peut dépasser l'indice maximal.

    Par ailleurs le code suivant ne sert à rien :
    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    if(tab_gauge[size] >= 255) tab_gauge[size] = 255;
    En effet, tab_gauge est un tableau d'entier 8 bits non signés. Il ne peut dépasser 255 (si on essaye : 255+1 = 0 etc.)

    Salutations
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  15. #15
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    Bonsoir, en fait je viens de m'apercevoir qu'il suffit d'incrémenter des 1 binaire pour ainsi allumer les pixels correspondant à la ligne

    D0     0    0     0     0     0      0       0       0      1 
    D1     0    0     0     0     0      0       0       1      1
    D2     0    0     0     0     0      0       1       1      1
    D3     0    0     0     0     0      1       1       1      1
    D4     0    0     0     0     1      1       1       1      1  
    D5     0    0     0     1     1      1       1       1      1
    D6     0    0     1     1     1      1       1       1      1
    D7     0    1     1     1     1      1       1       1      1
    
    val    0   128   192   224   240    248     252     254    255
    quelle opération puis-je faire pour ajouter du 1 sur un mot binaire ?

    Merci

  16. #16
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    Je verrais bien quelque chose comme ça

    Code C++ : 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
    void niveaux(uint8_t niveau_bat,unsigned char *tab_gauge)
    {
     
    uint8_t nbr_data;//=niveau_bat/2;  //valeur du soc compris entre 0 et 50 
    uint8_t i,k,l,temp;
    uint8_t size=133;
     
    temp=22;
    for(l=2 ; l>size ; l++) {tab_gauge[l]=0;}
    i=j=k=l=0;
     
    tab_gauge[0]=22;
    tab_gauge[1]=48;
     
    nbr_data = niveau_bat;  //rendre en proportion du tableau 
     
    		for(k=0; k < 6 ; k++)
    		{
     
                          for(l=0;l<8; l++)
                          {
                                    for(i=0; i<23 ; i++) // par ligne de 22 
                                   {
     
                                    size=size-i; 
    				tab_gauge[size]=(tab_gauge[size]>>1) || 0x80 ; 
     
     
     
                                   }
     
                          size=size+i;
                          nbr_data--;
                          if(nbr_data==0) {l=8; k=6;}       
                         }    
     
    		size=size-temp;
    		}
     
     
    }

  17. #17
    Membre éprouvé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 346
    Points : 1 211
    Points
    1 211
    Par défaut Petit à petit
    Bonsoir,

    Cela progresse mais ce n'est pas un ou logique ( || ) qu'il faut utiliser mais un ou binaire ( | ). C'est ce que je proposait dans le code alternatif. Par ailleurs comme tous les verticales intérieures d'une même ligne sont identiques, je précalcule la valeur dans un masque qui va se combiner avec les points de l'image de la batterie vide.
    Ce n'est pas | 0x80 sinon il n'y aurait qu'une seule ligne.

    • Si la valeur est supérieure à 8*l c'est 0xFF soit 255
    • Si la valeur est inférieure à 8*(l-1) c'est 0x00 soit 0
    • Si la valeur est entre les 2 c'est 2 << (nbr_data mod 8) soit 2 << (nbr_data and 7)


    Comme je ne sais pas où est le haut et le bas, il y a une chance sur 2 que le remplissage soit à l'envers.

    Bonne nuit
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  18. #18
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    Oui je m'en suis aperçu à l'expérimentation ce matin pour les ||

    Code C++ : 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
    void niveaux(uint8_t niveau_bat,unsigned char *tab_gauge)
    {
     
    uint8_t nbr_data;//=niveau_bat/2;  //valeur du soc compris entre 0 et 50 
    uint8_t i,k,l,temp;
    uint8_t size=133;
     
    temp=22;
    for(l=2 ; l>size ; l++) {tab_gauge[l]=0;}
    i=k=l=0;
     
    //tab_gauge[0]=22;
    //tab_gauge[1]=48;
     
    nbr_data = niveau_bat;  //rendre en proportion du tableau 
     
    		for(k=0; k < 6 ; k++)
    		{
     
                    for(l=0;l<8; l++)
                    {
                            for(i=0; i<23 ; i++) // par ligne de 22 
                            {
     
                            size=size-i; 
    						//tab_gauge[size]=(Image_batterie_vide[size]>>1) | 0x80 ; 
                            tab_gauge[size]=(tab_gauge[size] >>1) | 0x80 ;
                            //nbr_data--;   
     
                            }
     
                    size=size+i;
                    //nbr_data--;
                    if(nbr_data==0) {l=8; k=6;}       
                    }    
     
    		size=size-temp;
    		}
     
    tab_gauge[0]=22;
    tab_gauge[1]=48;
    }

    soit ça : tab_gauge[size]=(Image_batterie_vide[size]>>1) | 0x80 ;
    Nom : 20210111_093247.jpg
Affichages : 34
Taille : 1,05 Mo

    soit ça
    tab_gauge[size]=(tab_gauge[size] >>1) | 0x80 ;
    Nom : 20210111_093007.jpg
Affichages : 34
Taille : 1,10 Mo

    désolé, mais j'ai pas bien compris tes comparaison

  19. #19
    Membre du Club
    Homme Profil pro
    Electronicien
    Inscrit en
    août 2008
    Messages
    348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Electronicien
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : août 2008
    Messages : 348
    Points : 50
    Points
    50
    Par défaut
    je comprend pas, c'est saut de 8 à chaque fois ? pourtant je fais 8 passage sur chaque 22 données ... a chaque passage je fais un décallage du bit vers la droit puis je rajoute 1 au bit de poid fort ... au final on fini toujours par avoir un mot binaire qu'avec des un FFh.

    En fait, c'est comme si je passais qu'une fois sur 22 data à chaque fois ??

  20. #20
    Membre confirmé
    Femme Profil pro
    ..
    Inscrit en
    décembre 2019
    Messages
    204
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 91
    Localisation : Autre

    Informations professionnelles :
    Activité : ..

    Informations forums :
    Inscription : décembre 2019
    Messages : 204
    Points : 459
    Points
    459
    Par défaut
    Salut,

    Change les dimensions de ta batterie, ce sera plus simple. Et puis remplis que l'intérieure, les bords, c'est les bords.

Discussions similaires

  1. [JSmooth] Bien intégrer la JRE avec son programme
    Par Ceubex dans le forum EDI et Outils pour Java
    Réponses: 0
    Dernier message: 31/03/2012, 00h01
  2. Liste des fichiers ouverts avec son programme
    Par z4k4r14 dans le forum Langage
    Réponses: 3
    Dernier message: 27/02/2012, 15h41
  3. Utiliser 2 processeurs avec un programme en C
    Par frogway dans le forum C
    Réponses: 4
    Dernier message: 04/04/2009, 20h05
  4. Réponses: 1
    Dernier message: 23/07/2007, 12h00
  5. Ouvrir un fichier avec son programme
    Par aliwassem dans le forum Delphi
    Réponses: 1
    Dernier message: 21/10/2006, 22h26

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo