Programmation d'un processeur avec son afficheur

**davidif** · 13/12/2020, 15h29

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

**davidif** · 02/01/2021, 12h57

Bonjour et mes meilleurs vœux à tous,

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

**Vincent PETIT** · 04/01/2021, 12h05

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+

**Guesset** · 04/01/2021, 18h43

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

**davidif** · 05/01/2021, 11h55

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 : 178
Taille : 573,3 Ko

Nom : 20201204_093400.jpg
Affichages : 178
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

**Guesset** · 05/01/2021, 18h31

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

**davidif** · 08/01/2021, 15h10

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

**Guesset** · 08/01/2021, 16h53

Bonjour David,

Envoyé par davidif

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

**davidif** · 10/01/2021, 14h40

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.

**Guesset** · 10/01/2021, 16h50

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.

**davidif** · 10/01/2021, 17h24

Oui je me suis aperçu des erreur des for lorsque j'ai vu que je pouvais toujours attendre que ça rentre (:

**davidif** · 10/01/2021, 18h14

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 : 146
Taille : 1,73 Mo

**davidif** · 10/01/2021, 18h52

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

**Guesset** · 10/01/2021, 20h56

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

**davidif** · 10/01/2021, 21h47

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

**davidif** · 10/01/2021, 23h01

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;
		}
 
 
}

**Guesset** · 11/01/2021, 00h28

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

**davidif** · 11/01/2021, 09h36

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 : 118
Taille : 1,05 Mo

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

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

**davidif** · 11/01/2021, 10h16

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 ??