Problème afficheur 16*2 en 8bits , mais ok en 4 bits (lambda)

Bonjour à tous, je poste car je me tire les cheveux depuis plusieurs jours.

J’ai un programme qui me sert à afficher la richesse de mon moteur depuis une sonde lambda.

J’affiche la valeur en temps réelle sur un 16*2

Cependant impossible de le faire fonctionner autrement que en 4 bits (16*1)
Voici mon code en 4bits (qui fonctionne nickel)

#include <LiquidCrystal.h> //ajout de la librairie

// le potentiomètre, branché sur la broche analogique 0
const int potar = analogRead(0);
//variable pour stocker la valeur lue après conversion
int valeurLue;
//on convertit cette valeur en une tension
float tension;
int afr;

const int RS=11; //declaration constante de broche
const int E=10; //declaration constante de broche
const int D7=2; //declaration constante de broche
const int D6=3; //declaration constante de broche
const int D5=4; //declaration constante de broche
const int D4=5; //declaration constante de broche 


//Vérifier les broches !
LiquidCrystal lcd(RS,E,D4,D5,D6,D7); //liaison 8 bits de données
  
void setup()
{
    lcd.begin(16,2); //utilisation d'un écran 16 colonnes et 2 lignes
    delay(10);
    lcd.clear(); // // efface écran et met le curseur en haut à gauche
    delay(10); // pour laisser temps effacer écran
}
  
void loop() {  //on convertit en nombre binaire la tension lue en sortie du potentiomètre
    valeurLue = analogRead(potar);
    
    //on traduit la valeur brute en tension (produit en croix)
    tension = valeurLue * 5.0 / 1023;
    float afr = (float)tension * 3;
    
      lcd.begin(16,2); //utilisation d'un écran 16 colonnes et 2 lignes
      lcd.clear();
    delay(10);
    lcd.clear(); // // efface écran et met le curseur en haut à gauche
    delay(10); // pour laisser temps effacer écran
    lcd.print("U="); //petit test pour vérifier que tout marche
    lcd.print(tension);
    lcd.print("V");
    lcd.print(" Afr=");
    lcd.print(afr);
    
    //on attend une demi-seconde pour que l'affichage ne soit pas trop rapide
    delay(100);}

Et voici mon code en 8bits avec affichage souhaité sur les 2 colonnes, mais qui m’affiche absolument n’importe quoi ( du type “25 dj#j ç’_glmfle,ç”'çvide" )

#include <LiquidCrystal.h> //ajout de la librairie

// le potentiomètre, branché sur la broche analogique 0
const int potar = analogRead(0);
//variable pour stocker la valeur lue après conversion
int valeurLue;
//on convertit cette valeur en une tension
float tension;
int afr;

const int RS=11; //declaration constante de broche
const int E=10; //declaration constante de broche
const int D7=2; //declaration constante de broche
const int D6=3; //declaration constante de broche
const int D5=4; //declaration constante de broche
const int D4=5; //declaration constante de broche 
const int D3=6; //declaration constante de broche
const int D2=7; //declaration constante de broche
const int D1=8; //declaration constante de broche
const int D0=9; //declaration constante de broche 

//Vérifier les broches !
LiquidCrystal lcd(RS,E,D0,D1,D2,D3,D4,D5,D6,D7); //liaison 8 bits de données
  
void setup()
{
    lcd.begin(16,2); //utilisation d'un écran 16 colonnes et 2 lignes
    delay(10);
    lcd.clear(); // // efface écran et met le curseur en haut à gauche
    delay(10); // pour laisser temps effacer écran
}
  
void loop() {  //on convertit en nombre binaire la tension lue en sortie du potentiomètre
    valeurLue = analogRead(potar);
    
    //on traduit la valeur brute en tension (produit en croix)
    tension = valeurLue * 5.0 / 1023;
    float afr = (float)tension * 3;
    
      lcd.begin(16,2); //utilisation d'un écran 16 colonnes et 2 lignes
      lcd.clear();
    delay(10);
    lcd.clear(); // // efface écran et met le curseur en haut à gauche
    delay(10); // pour laisser temps effacer écran
    lcd.print("U="); //petit test pour vérifier que tout marche
    lcd.print(tension);
    lcd.print("V");
    lcd.print(" Afr=");
    lcd.print(afr);
    
    //on attend une demi-seconde pour que l'affichage ne soit pas trop rapide
    delay(100);}

Je n’arrive pas à comprendre ce qui ne vas pas dans mon code, si un oeil avisé pourrait m’aider ce serait formidable !

Merci d’avance

bonjour,
que fait ceci dans le loop?

    lcd.begin(16,2); //utilisation d'un écran 16 colonnes et 2 lignes

en plus tu as des lcd.clear() par 3 fois dans le loop, tu dois pas voir grand chose

Attention, tu as l'air de penser que le 4 bit permet l'affichage d'une seule ligne, c'est pas le cas.
L'écran avec la lib liquidcrystal fonctionnera de la même manière en 4 ou 8 bits.

Es tu sûr de ton câblage en 8bits?

Apres pourquoi doubler tes lcd.clear à chaque fois? Et de les espacer d'un delay(10), c'est pas nécessaire.

hello

ta declaration

const int potar = analogRead(0); te donne n’importe quoi

remplace par

const int potar = A0;

puis pour ton setup et ta loop regarde ce code et joue avec pour connaitre l’instruction set curseur

void setup()
{
    lcd.begin(16,2); //utilisation d'un écran 16 colonnes et 2 lignes
    delay(10);       //lcd begin place le curseur en haut à gauche ( en colonne 0, ligne 0)
    lcd.print("U="); 
    lcd.setCursor(7, 0);          //place le curseur en colonne 7, ligne 0
    lcd.print("V");
    lcd.setCursor(0, 1);          //place le curseur en colonne 0, ligne 1
    lcd.print("Afr=");
}
 
void loop() {  //on convertit en nombre binaire la tension lue en sortie du potentiomètre
    valeurLue = analogRead(potar);
    //on traduit la valeur brute en tension (produit en croix)
    tension = valeurLue * 5.0 / 1023;
    float afr = (float)tension * 3;
    lcd.setCursor(3, 0);          //place le curseur en colonne 3, ligne 0
    lcd.print(tension);
    lcd.setCursor(5, 1);          //place le curseur en colonne 5, ligne 1
    lcd.print(afr);
    //on attend une demi-seconde pour que l'affichage ne soit pas trop rapide
    delay(100);}

Merci à tous pour vos réponse, j’arrive à écrire sur les 2 lignes en 4 bits c’est top.

Voici le code en question allégé :

#include <LiquidCrystal.h> //ajout de la librairie

//La sonde lambda, branché sur la broche analogique 0
const int lambda = A0;

//variable pour stocker la valeur lue après conversion
int valeurLue;

//variable pour stocker la valeur d'AFR calculée depuis la tension
int afr;

//on convertit cette valeur en une tension
float tension;


const int RS=11; //declaration constante de broche
const int E=10; //declaration constante de broche
const int D7=2; //declaration constante de broche
const int D6=3; //declaration constante de broche
const int D5=4; //declaration constante de broche
const int D4=5; //declaration constante de broche 


//Vérifier les broches 
LiquidCrystal lcd(RS,E,D4,D5,D6,D7); //liaison 8 bits de données

//initialisation de l'écran
void setup()
{
    lcd.begin(16,2); //utilisation d'un écran 16 colonnes et 2 lignes
    lcd.clear(); // // efface écran et met le curseur en haut à gauche
    delay(10); // pour laisser temps effacer écran
}

//démarrage de la boucle
void loop() 

{  
  
    //on convertit en nombre binaire la tension lue en sortie du potentiomètre
    valeurLue = analogRead(potar);
    
    //on traduit la valeur brute en tension (produit en croix)
    tension = valeurLue * 5.0 / 1023;
    
    //on transforme la tension en valeur d'AFR (selon courbe sonde reliée)
    float afr = -(float)tension * 1.4214 + 13.334;
    
    //affichage sur les deux lignes du l'ecran 16*2
    lcd.clear();
    delay(10);
    lcd.setCursor(0, 0);
    lcd.print("Tension="); 
    lcd.print(tension);
    lcd.print("Volts");
    lcd.setCursor(0, 1);
    lcd.print("Afr=");
    lcd.print(afr);
}

// fin de la boucle

Ducoup plusieurs questions me viennent à l’esprit :

Quelle est l’utilité du 8 bits ?

Pourquoi ça ne fonctionne pas en 8 bits ?

Mon branchement me parait bon ( je l’ai vérifier plusieurs fois ) les 4 bits supplémentaires sont branchés dans la continuité des autres, j’ai les correspondances Ecran / Arduino R3 suivantes :

( RS à 11 ; E à 10 ; D0 à 9 ; D1 à 8 ; D2 à 7 ; D3 à 6 ; D4 à 5; D5 à 4; D6 à 3; D7 à 2)

Ma “const int potar;” fonctionnais bien ( valeur affiché ok) pourquoi remplacer par “const int potar = A0;”

Merci encore à tous, je vais maintenant pouvoir peaufiner ma reprogrammation éthanol sur ma voiture en ayant une bonne visibilité LCD ^^

tu déclares:

const int potar = analogRead(0);

cette ligne dit:
potar=valeur lue sur la pin D0, personne ne sait ce que tu y trouves ( coup de pot elle te donne 0)

puis tu fais:
valeurLue = analogRead(potar);

cette ligne dit: valeur=ce qui se trouve sur l'entrée analogique A0 ( parce que tu as eu du pot)

si tu fais
const int potar = A0;
puis
valeurLue = analogRead(potar); là tu sais que tu vas lire l'entrée ana A0 sur laquelle est raccordée ton potar

l'utilité du 8 bits?
je ne pense pas que quelqu'un utilise le mode 8 bits, il te bouffe 4 entrées supplémentaires........