Aide pour comprendre un programme

Bonjour,

J'ai encore besoin d'aide :smiley: , j'aime bien comprendre un programme que je vais utiliser, c'est pour ça que j'aimerais quelques clarifications sur le programme en dessous :

Ce programme permet d'afficher une barre de chargement sur un écran LCD.

#include <LiquidCrystal.h>



LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Pins de l'afficheurs lcd
int i, j ; //Déclaration de i et j, variables égales à zéro
byte barre[] = { //Création du caractère de chargement
B111111,
B111111,
B111111,
B111111,
B111111,
B111111,
B111111,
B111111
};
void setup() {
lcd.begin(16, 2); //Activation de l'afficheur lcd
}
void loop() {
while(i != 100){
while(i < 100){
lcd.createChar(1, barre); //Déclaration du caractère de chargement
delay(100); //On attends 250 ms
i++ ; //i augmente de 1
lcd.setCursor(0, 0); //On place le curseur à la colonne 8, ligne 1
lcd.print(i); //On écrit la valeur de i
lcd.print("%"); //Puis le signe % (pourcent)
affichage(); //Utilisation de la fonction affichage déclarée plus bas
if(i == 100){
lcd.clear(); //Si i = 100, on efface l'écran
}
}
while(i == 100 && j < 16){
lcd.setCursor(0, 0); //On place le curseur à la colonne 8, ligne 1
lcd.print(i); //On écrit la valeur de i
lcd.print("%"); //Puis le signe % (pourcent)
lcd.setCursor(j, 1); //On place le curseur à la colonne égale à la valeur de j et à la ligne 2
lcd.write(byte(1)); //On affiche le caractère de chargement
j++ ; //j augmente de 1
}
}
}
void affichage(){ //Fonction permettant de gérer l'affichage du caractère de chargement. Je ne la détaillerai pas ici
switch(i){
case 5 :
lcd.setCursor(0, 1);
lcd.write(byte(1));
break ;
case 10 :
lcd.setCursor(1, 1);
lcd.write(byte(1));
break ;
case 15 :
lcd.setCursor(2, 1);
lcd.write(byte(1));
break ;
case 20 :
lcd.setCursor(3, 1);
lcd.write(byte(1));
break ;
case 25 :
lcd.setCursor(4, 1);
lcd.write(byte(1));
break ;
case 30 :
lcd.setCursor(5, 1);
lcd.write(byte(1));
break ;
case 35 :
lcd.setCursor(6, 1);
lcd.write(byte(1));
break ;
case 40 :
lcd.setCursor(7, 1);
lcd.write(byte(1));
break ;
case 45 :
lcd.setCursor(8, 1);
lcd.write(byte(1));
break ;
case 50 :
lcd.setCursor(9, 1);
lcd.write(byte(1));
break ;
case 55 :
lcd.setCursor(10, 1);
lcd.write(byte(1));
break ;
case 60 :
lcd.setCursor(11, 1);
lcd.write(byte(1));
break ;
case 65 :
lcd.setCursor(12, 1);
lcd.write(byte(1));
break ;
case 70 :
lcd.setCursor(13, 1);
lcd.write(byte(1));
break ;
case 75 :
lcd.setCursor(14, 1);
lcd.write(byte(1));
break ;
case 80 :
lcd.setCursor(1, 1);
lcd.write(byte(1));
break ;


}
}

1.

while(i != 100){
}

Je voudrais savoir, pourquoi mettre cette condition, le programme marche sans.

2.

while(i == 100 && j < 16){
lcd.setCursor(0, 0); //On place le curseur à la colonne 8, ligne 1
lcd.print(i); //On écrit la valeur de i
lcd.print("%"); //Puis le signe % (pourcent)
lcd.setCursor(j, 1); //On place le curseur à la colonne égale à la valeur de j et à la ligne 2
lcd.write(byte(1)); //On affiche le caractère de chargement
j++ ; //j augmente de 1
}

Cette partie permet d'afficher une barre complète si j'ai bien compris ("j" représente une colonne, on place le curseur à la colonne "j", on remplit puis on ajoute 1 à "j" jusqu'à avoir une barre complète).

3.

switch(i){
case 5 :
lcd.setCursor(0, 1);
lcd.write(byte(1));

J'ai compris que l'on remplit la case indiqué par la commande "lcd.setCursor" mais je comprend pas très bien le "switch(i)" et le "lcd.write(byte(1))" (d'où provient le "byte(1)").

Ça m'aiderait de comprendre ce programme.

Je vous souhaite une bonne journée ou soirée.

Parce que vous avez récupéré un code un peu pourri :grin: :grin:

J-M-L:
Parce que vous avez récupéré un code un peu pourri :grin: :grin:

Génial :stuck_out_tongue_closed_eyes: , j'en a trouvé que 2, le deuxième tourne en boucle et impossible de modifier la vitesse :confused:

Je cherche juste une barre progressive qui se stop à la fin.

Un lien pour une barre de progression sur un lcd

lesept:
Un lien pour une barre de progression sur un lcd

Oui je l'ai vu, mais je la trouve trop complexe.

Finalement j'ai simplifié, ça donne cela :

#include <LiquidCrystal.h>



LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 
int i = 0 ; 
byte barre[] = { 
B111111,
B111111,
B111111,
B111111,
B111111,
B111111,
B111111,
B111111
};
void setup() {
lcd.begin(16, 2); 
}
void loop() {
  
lcd.clear();
i = 0;
while(i < 100){
lcd.createChar(0, barre); 
i++ ; 
lcd.setCursor(0, 0); 
lcd.print(i); 
lcd.print("%"); 
affichage(); 
 delay (30);
}

}

void affichage(){ 
switch(i){
case 5 :
lcd.setCursor(0, 1);
lcd.write(byte(1));
break ;
case 10 :
lcd.setCursor(1, 1);
lcd.write(byte(1));
break ;
case 15 :
lcd.setCursor(2, 1);
lcd.write(byte(1));
break ;
case 20 :
lcd.setCursor(3, 1);
lcd.write(byte(1));
break ;
case 25 :
lcd.setCursor(4, 1);
lcd.write(byte(1));
break ;
case 30 :
lcd.setCursor(5, 1);
lcd.write(byte(1));
break ;
case 35 :
lcd.setCursor(6, 1);
lcd.write(byte(1));
break ;
case 40 :
lcd.setCursor(7, 1);
lcd.write(byte(1));
break ;
case 45 :
lcd.setCursor(8, 1);
lcd.write(byte(1));
break ;
case 50 :
lcd.setCursor(9, 1);
lcd.write(byte(1));
break ;
case 55 :
lcd.setCursor(10, 1);
lcd.write(byte(1));
break ;
case 60 :
lcd.setCursor(11, 1);
lcd.write(byte(1));
break ;
case 65 :
lcd.setCursor(12, 1);
lcd.write(byte(1));
break ;
case 70 :
lcd.setCursor(13, 1);
lcd.write(byte(1));
break ;
case 75 :
lcd.setCursor(14, 1);
lcd.write(byte(1));
break ;
case 90 :
lcd.setCursor(15, 1);
lcd.write(byte(1));
break ;
}
}

Simple rapide il suffit d'enlever "lcd.clear()" et "i=0" en début de void loop() si on veut que ça ne recommence pas.
Pour gérer la durée de la barre, il suffit de rajouter un petit "delay()".

aquajon:
Oui je l'ai vu, mais je la trouve trop complexe.

Moi j'ai une petite fonction:

void showPercent(percent, col, row, width)

qui permet d'afficher un pourcentage ([color=blue]percent[/color] entre 0 et 100) à partir de la position sur l'écran ([color=blue]col[/color], [color=blue]row[/color]) sur [color=blue]width[/color] caractères de large. On n'est donc pas obligé de prendre toute une ligne mais les valeur par défaut des 3 derniers paramètres peuvent être en (0,0) pour toute la largeur de l'affichage auquel cas on appelle juste showPercent(percent);

J'utilise la librairie I2C de fdebrabander sur des écrans ou chaque caractère est une matrice de 8 pixels de haut sur 5 de large.

ce code (qui contient la fonction) va remplir une ligne de 0% à 100% sur une zone de 10 caractères en position (5,1)

#include <LiquidCrystal_I2C.h>  //  https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
// adress LDC 0x27  16 x 2
// adress LDC 0x3F  20 x 4
const uint8_t lcdAddress = 0x3F;
const uint8_t nbRows = 4;
const uint8_t nbCol = 20;
LiquidCrystal_I2C lcd(lcdAddress, nbCol, nbRows);

uint8_t verticalBar[5][8] =
{
  {0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000},
  {0b11000, 0b11000, 0b11000, 0b11000, 0b11000, 0b11000, 0b11000, 0b11000},
  {0b11100, 0b11100, 0b11100, 0b11100, 0b11100, 0b11100, 0b11100, 0b11100},
  {0b11110, 0b11110, 0b11110, 0b11110, 0b11110, 0b11110, 0b11110, 0b11110},
  {0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111},
};

// percent = 0% --> no line, 100% --> width full blocks at position (col,row). linear in between
void showPercent(const uint8_t percent, const uint8_t col = 0, const uint8_t row = 0, const uint8_t width = nbCol)
{
  const uint16_t maxRange = 5 * width; // number of vertical bars to represent 100%
  const uint16_t nbVerticalLines = (percent * maxRange) / 100;
  const uint16_t nbFullBlocs = nbVerticalLines / 5;
  const uint16_t nbVerticalLinesInLastBloc = nbVerticalLines % 5;
  const uint16_t nbEmptyBlocs = width - nbFullBlocs - (nbVerticalLinesInLastBloc == 0 ? 0 : 1);

  // position at the start of the area
  lcd.setCursor(col, row);

  // start filling in full blocks
  for (uint8_t b = 0; b < nbFullBlocs; b++)
    lcd.write(0x4);

  // add what's needed for in the last block
  if (nbVerticalLinesInLastBloc != 0) lcd.write(nbVerticalLinesInLastBloc - 1);

  // erase rest of the area
  for (uint8_t b = 0; b < nbEmptyBlocs; b++)
    lcd.write(' ');
}

void setup() {
  Serial.begin(115200);
  lcd.begin();
  lcd.backlight();
  for (uint8_t b = 0; b < 5; b++)
    lcd.createChar(b, verticalBar[b]);


  // affiche FUEL: et rempli de 0% à 100% juste à côté  
  lcd.setCursor(0, 1);
  lcd.print(F("FUEL:"));

  for (uint8_t p = 0; p <= 100; p++) {
    showPercent(p, 5, 1, 10); // rempli de 0% à 100% sur une zone de 10 caractères en position (5,1)
    delay(10);
  }
}

void loop() {}

Le principe est assez simple, on définit 5 caractères spéciaux qui représentent une barre verticale remplie, deux barres, 3 barres, 4 barres et le bloc complet.

la fonction ensuite fait un peu de maths pour voir combien de blocs complets on doit afficher et s'il y a un reste, on affiche le bon nombre de barres verticales, puis on finit d'effacer la zone avec des espaces.

Le nom des variables devrait être assez parlant pour comprendre ce que ça fait.