Discussion :

[davidif]

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]

Bonjour et mes meilleurs vœux à tous,

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

[Vincent PETIT]

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]

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]

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.


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]

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