aide arduino uno programmation

[invite4137e186]

par contre pour l'alim je suis sûr que c'est 5V car il est écrit sur le papier donc il me faut juste la fréquence du quartz qui est soit 8 ou 16 MHz
-----

[invite4137e186]

sinon le programme exacte soit avec l'activation des pull-up que j'ai oublié de faire dans le précedent le voici:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);
// Set the LCD address to 0x27 for a 16 chars and 2 line display


 const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
  const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
  const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino

void setup() {

  Serial.begin(9600); //Lancer le mode série


  // initialize the LCD
  lcd.begin();

  // Turn on the blacklight and print a message.
  lcd.backlight();

    pinMode(bouton1, INPUT);
    digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton2, INPUT);
    digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton3, INPUT);
    digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
}

void loop()
{
}

je vais avoir besoin d'aide pour afficher sur la ligne du haut les paramètres et comment on les changent avec les BP car je sais le faire en programme mais pas avec les BP

[invite1d577638]

Tu as simplement besoin de générer une chaine de caractères en fonction de ce qui est lu par tes boutons.

Bon c'est pas du code arduino mais ça te donne l'idée :

if Bouton == true { reglage = "bonjour"   } else { reglage = "bonsoir"  }

Chaine = "Paramètre 1:"  & reglage

C'est concat je crois pour mettre des strings à la suite...

[invite4137e186]

il y a un truc que je comprends pas avec ces BP

soit il est appuyé soit relaché donc supposons que quand il est relaché le débit reste à 9600 et que si j’appuie et qu'il soit relâché après alors la vitesse passe à 14400 puis 19200 ...

je ne vois pas comment écrire sa en coe arduino que à chaque fois que j'appuie on passe à la valeur au dessus jusque 115200 et après on retourne à 300

[invite1d577638]

Il te fallait des bistables (qui restent sur une position donnée : ouverte ou fermée)...

Enfin, rien ne t'empêche de faire un inverseur soft (appui : mise à 1, réappui : mise à 0 )

[invite4137e186]

a oui je vois ce que vous voulez dire mais comment écrire sa en code y a t-il des exemples sur internet ?

[invite1d577638]

Bien sûr !

Bon je t'aide : utilise la fonction NOT qui permet d’inverser l'état d'une variable binaire.

[invite4137e186]

voici un début de code pour moi passer de 9600 à 14400 et l'afficher. pas d'erreurs quand je compile.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);
// Set the LCD address to 0x27 for a 16 chars and 2 line display


 const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
  const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
  const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino
  
   int etatBouton1;
   int etatBouton2;
   int etatBouton3;

void setup() {

  Serial.begin(9600); //Lancer le mode série


  // initialize the LCD
  lcd.begin();

  // Turn on the blacklight and print a message.
  lcd.backlight();

    pinMode(bouton1, INPUT);
    digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton2, INPUT);
    digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton3, INPUT);
    digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
}

void loop()
{
   etatBouton1 = digitalRead(bouton1); //Rappel : bouton = 2
   int A; // A représente le débit de la carte qui sera afficher sur le lcd
   
   if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
   {
       Serial.begin(9600); //je reste à 9600
       A=9600;
       lcd.print (A);
   }
   else  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
   {
       Serial.begin(14400); //le bouton est appuyé, le débit passe à 14400
        A=14400;
       lcd.print (A);
   }
}

mais je vois pas comment écrire en code que je veux si je rappui passer encore à une autre valeur soit 19200 puis etc

[invite1d577638]

Tu crée une variable binaire qui définit ta vitesse, variable que tu inverses à chaque détection de pression sur ton bouton avec la fonction NOT.

[invite4137e186]

Bonjour

j'ai envoyé à mon tuteur le petit dossier que j'avais fais. Dedans il y a mes recherches pour l'alimentation de la mini arduino, pour les boutons poussoirs et comment j'active les résistantes pull up avec la programmation. mais il me dit qu'il n'y a rien dedans qu'il manque le traitement de la partie RS232

[invite1d577638]

Et...?

ça fait trois semaines qu'on te demande de cadrer/arrêter ce sur quoi tu dois EXACTEMENT travailler. Tu ne sembles pas savoir exactement à quoi va servir ton engin ni à quoi il va être relié. Nous on va rien pouvoir faire de plus...

Tu as pourtant bien compris comment mettre un MAX232 dans ton circuit...

[invite4137e186]

je sais ce que je dois afficher sur l'écran mais non je ne vois pas à quoi vas me servir le max232 car pour faire les tests après que j'aurais trouvé le programme je me sers juste de l'écran, de l'arduino uno et des BP.

Mais à la fin si mon programme fonctionne que j'affiche correctement ce qu'il faut sur la ligne du haut et du bas et que les BP fonctionnent, que quand j'appuie ils changent bien les paramètres. alors la je soude sur la plaque la mini arduino, le max232 et je relie tx-rx et rx-tx comme les modéles sur internet. Mais la j'avoue que je ne vois pas en quoi il vas me servir le max car lors des tests je ne m’en sert pas

[invite1d577638]

Fait déjà marcher tes boutons...

N'oublie pas que la "mini arduino" ne comporte pas d'interface USB, mais juste un UART matériel...

[invite4137e186]

ok sa marche, sinon voici ce que j'ai compris.

Le MAX232 sert d'interface entre une liaison série TTL (0-5V) et une liaison série RS232 (+12 -12V) et ce avec une simple alimentation 5V.

La liaison série asynchrone est un moyen de communication entre deux systèmes électroniques facile à mettre en œuvre. Ainsi, la plupart des micro-contrôleurs modernes disposent d'un circuit spécialisé (UART) leur permettant d'échanger des données avec l'extérieur de cette manière.

Par conséquent, si on veut connecter une sortie série utilisant les niveaux TTL à son ordinateur, il faut un adaptateur spécialisé. Ici se sera mon MAX232 qui est l'adaptateur pour connecter la mini arduino avec le PC parce qu'elle n'apas de port USB mais un UART matériel.

[invite1d577638]

Par conséquent, si on veut connecter une sortie série utilisant les niveaux TTL à son ordinateur, il faut un adaptateur spécialisé. Ici ce sera mon MAX232 qui est l'adaptateur pour connecter la mini arduino avec le PC parce qu'elle n'a pas de port USB mais un UART matériel.

Après il n'y a pas que le MAX232... Dans une arduino UNO (qui pour rappel permet d'échanger des données avec un PC) c'est autre chip (FTDI souvent, ou un autre base Atmel) qui lui fait un pont non pas entre du TTL et du ±12, mais entre du TTL et un protocole USB. Il n'y a pas du tout de ±12v, car ce n'est pas nécessaire. Et c'est ce chip d'interface entre 0..5v et USB qui n'est pas présent sur la arduino "mini".

[invite4137e186]

Bonjour

je vais enfin avoir un ordinateur et pouvoir continuer le projet.

j'ai modifié un peu le programme.

pour éviter d'écrire 11 fois la même chose pour changer 11 fois la vitesse, j’utilise A pour mémoriser le debit en cours, du coup, je vais changer A et n'écrire le reste qu'une fois comme :

if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
   {
       A=9600;      
   }
   else  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
   {       
        A=14400;     
   }
 
   Serial.begin(A);
   lcd.print (A);

je vais utiliser un tableau pour mettre les valeurs possibles.

float valeurdudebit[11] = {300,1200,2400,4800,9600,14400,19200,28800,38400,57600,115200};

Ensuite,je sais que le test va être fait plusieurs fois dans une seconde, hors ce que je veux, c'est changer la valeur une seule fois à chaque appui et non la changer tant qu'on est appuyé...

je dois détecter un front montant du bouton, donc un changement d'état de bas vers haut, je sais que on a un front montant quand le signal est à 1 alors qu'il était à 0.

est ce à ce moment que je dois utiliser la fonction NOT ?

[invite4137e186]

Bonjour

Avant de continuer la programmation j'aurais une petite question.

pouvez vous me dire si c'est correcte.

Le MAX232 sert d'interface entre une liaison série TTL (0-5V) et une liaison série RS232 (+12 -12V) et ce avec une simple alimentation 5V.

La liaison série asynchrone (TTL) est un moyen de communication entre deux systèmes électroniques facile à mettre en œuvre. La plupart des microcontrôleurs modernes disposent d'un circuit spécialisé (UART) leur permettant d'échanger des données avec l'extérieur. Sur cette liaison, une tension de 0V correspond à un 0 logique. Une tension de 3.3V ou 5V selon la tension nominale du circuit correspond à un 1 logique.
Cette liaison s'apparente à la liaison RS-232 dont certains PC sont encore équipés, mais elle s'en différencie par les tensions utilisées.
En RS-232, un 1 logique correspond à une tension entre -3V et -25V et un 0 logique à une tension entre +3 et +25V.

Par conséquent, si on veut connecter une sortie série utilisant les niveaux TTL soit la mini Arduino à son ordinateur, il faut un adaptateur spécialisé. Ici se sera mon MAX232 qui est l'adaptateur pour connecter la mini Arduino avec le PC parce qu'elle n'a pas de port USB mais un UART matériel qui est le composant utilisé pour faire la liaison entre l'ordinateur et le port série (synonyme de RS232).

Pour connecter le max232 à la mini arduino j'utilise le shéma suivant :

http://www.google.fr/imgres?imgurl=h...ed=0CF4QrQMwAg

voila mais je ne sais pas comment connecter le pc à l'arduino car j'ai le composant qui permet de faire l'interface mais il me faudra quand même un USB pour tout connecter à l'ordi et envoyer le programme dans le microcontrôleur nn ?

[invite4137e186]

Serai-ce ma prise SUB-D9 femelle qui va me permettre de tout connecter au PC pour envoyer le programme au microcontrôleur de la mini arduino ?

[invite1d577638]

Le MAX232 sert d'interface entre une liaison série TTL (0-5V) et une liaison série RS232 (+12 -12V) et ce avec une simple alimentation 5V.

La liaison série asynchrone (TTL) est un moyen de communication entre deux systèmes électroniques facile à mettre en œuvre. La plupart des microcontrôleurs modernes disposent d'un circuit spécialisé (UART) leur permettant d'échanger des données avec l'extérieur. Sur cette liaison, une tension de 0V correspond à un 0 logique. Une tension de 3.3V ou 5V selon la tension nominale du circuit correspond à un 1 logique.
Cette liaison s'apparente à la liaison RS-232 dont certains PC sont encore équipés, mais elle s'en différencie par les tensions utilisées.
En RS-232, un 1 logique correspond à une tension entre -3V et -25V et un 0 logique à une tension entre +3 et +25V.

On t'as déjà dit que c'était bon.. cf page précédente.

Oui, pour programmer le micro, il va te falloir passer soit par un adaptateur USB/série que tu viens brancher sur le TX/RX de ta carte (exemple), soit par un port série physique de pc à travers un MAX232.

[invite4137e186]

//*********** Librairies utilisées **********//
#include <LiquidCrystal_I2C.h>
#include <Wire.h>

//***********  Règle la taille du LCD : 16 colonnes et 2 lignes **********//
LiquidCrystal_I2C lcd(0x27, 16, 2);



 const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
  const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
  const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino
  
   int etatBouton1;
   int etatBouton2;
   int etatBouton3;
   
   //***********  tableau avec les 11 valeurs de débit possible **********//
   float valeurdudebit[11] = {300,1200,2400,4800,9600,14400,19200,28800,38400,57600,115200};

void setup() {

  Serial.begin(9600); //Lancer le mode série


  // Initialiser l'écran LCD
  lcd.begin();

  // Allumer la lumiére noire : obligé d'être écrit pour faire fonctionner l'écran
  lcd.backlight();

    pinMode(bouton1, INPUT);
    digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton2, INPUT);
    digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton3, INPUT);
    digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
}

void loop()
{
   etatBouton1 = digitalRead(bouton1); //Rappel : bouton = 2
   int A; // A représente le débit de la carte qui sera afficher sur le lcd
   int i=0;
    
 if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
   {
       A=9600;      
   }
   else  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
   {       
        A=valeurdudebit[i];
        i++;     
   }
 
   Serial.begin(A);
   lcd.print (A);
   
}

Pour pouvoir changer le débit avec le bouton poussoir et l'afficher sur l'écran, je pensais créer un tableau avec les 11 valeurs de débits. que pensez vous du code (pour l'instant je ne peux pas compiler car mon pc ne le permet pas, j'ai un petit netbook et il manque le logiciel et la connexion ne me permet pas d'installer quoi que se soit car elle saute souvent, rien que pour faire ce message, il m'a fallu 25 minutes d'attente lol)

je compilerais chez moi ce soir

[invite1d577638]

On pensera des choses sur le code quand on aura un cahier des charges clair, avec une explication exacte de ce à quoi servent tout les boutons et ce à quoi doit servir la carte.

Pour ton code, le meilleur est effectivement que tu l'essaie... Enfin bon, ta boucle loop semble étrange...

[invite4137e186]

voici en gros ce que je dois faire

je dois écrire un programme le mettre dans le microcontroleur de l'arduino mini sa ok

Le programme doit me permettre de :
changer le débit, la parité et le nombre de bits stop avec 3 boutons poussoirs

par exemple à chaque appuie sur le BP 1 je change de valeur de débit je passe de 9600 à 14400 si je r'appuie je passe à la prochaine valeur.


Le problème avec l'ordinateur que j'utilise est qu'il me manque des librairies car quand je compile le code suivant :

#include <LiquidCrystal_I2C.h>

//*********** Librairies utilisées **********//
#include <LiquidCrystal_I2C.h>
#include <Wire.h>

//***********  Règle la taille du LCD : 16 colonnes et 2 lignes **********//
LiquidCrystal_I2C lcd(0x27, 16, 2);



 const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
  const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
  const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino
  
   int etatBouton1;
   int etatBouton2;
   int etatBouton3;
   
   //***********  tableau avec les 11 valeurs de débit possible **********//
   float valeurdudebit[11] = {300,1200,2400,4800,9600,14400,19200,28800,38400,57600,115200};

void setup() {

  Serial.begin(9600); //Lancer le mode série


  // Initialiser l'écran LCD
  lcd.begin();

  // Allumer la lumiére noire : obligé d'être écrit pour faire fonctionner l'écran
  lcd.backlight();

    pinMode(bouton1, INPUT);
    digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton2, INPUT);
    digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton3, INPUT);
    digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
}

void loop()
{
   etatBouton1 = digitalRead(bouton1); //Rappel : bouton = 2
   int A; // A représente le débit de la carte qui sera afficher sur le lcd
   int i=0;
    
 if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
   {
       A=9600;      
   }
   else  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
   {       
        A=valeurdudebit[i];
        i++;     
   }
 
   Serial.begin(A);
   lcd.print (A);
   
}

la première est :
projet_1.ino: In function 'void setup()':
projet_1:29: error: no matching function for call to 'LiquidCrystal_I2C::begin()'
C:\Documents and Settings\Manu\Mes documents\Arduino\libraries\ic i/LiquidCrystal_I2C.h:59: note: candidates are: void LiquidCrystal_I2C::begin(uint8 _t, uint8_t, uint8_t)

d'après mon maitre de stage, il me faut plusieurs librairies mais je ne vois pas lesquelles car jusqu'a présent je n'utilisais que liquidcrystal_I2C que j'ai installé dans le logicile arduino de mon netbook mais les erreurs restent, pas moyen de compiler

[invite1d577638]

Ce code compile sans problèmes chez moi. Relis tes posts du début du sujet, tu as déjà eu des problèmes de librairie qui se sont bien résolus.

Ta boucle loop ne marchera pas. Il faut que tu gère le front de montée de ton bouton pour faire défiler tes vitesses... Met des déclarations de i et a dans le setup. Là, quand tu vas appuyer sur le bouton, ta vitesse va être mise à 9600, et quand il va être à 0, eh bien... ça va planter.

[invite4137e186]

j'ai fait la même manipulation que chez moi avec mon pc et je sais que chez moi sa compile. je c pas si c'est le netbook mais en librairie j'ai exactement le même que chez moi. j'ai bien relue ce qu'on avait fait mais la sa ne fonctionne tj pas

[invite1d577638]

Et si tu vérifiais que les librairies concernées sont effectivement présentes dans les bons dossiers ?

PS : Fait gaffe à ton orthographe... "ça compile", et évite le langage SMS. Merci.

[invite4137e186]

voici le code que j'ai écris :

//*********** Librairies utilisées **********//
#include <LiquidCrystal_I2C.h>
#include <Wire.h>

//***********  Règle la taille du LCD : 16 colonnes et 2 lignes **********//
LiquidCrystal_I2C lcd(0x27, 16, 2);



 const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
  const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
  const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino
  
   int etatBouton1;
   int etatBouton2;
   int etatBouton3;
   
   //***********  tableau avec les 11 valeurs de débit possible **********//
   float valeurdudebit[11] = {300,1200,2400,4800,9600,14400,19200,28800,38400,57600,115200};
 int A;
    int i=0;
void setup() {

  Serial.begin(9600); //Lancer le mode série


  // Initialiser l'écran LCD
  lcd.begin();

  // Allumer la lumiére noire : obligé d'être écrit pour faire fonctionner l'écran
  lcd.backlight();

    pinMode(bouton1, INPUT);
    digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton2, INPUT);
    digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton3, INPUT);
    digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    
   // A représente le débit de la carte qui sera afficher sur le lcd

}

void loop()
{
   
   etatBouton1 = digitalRead(bouton1); //Rappel : bouton = 2
  
    
 if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
   {
       A=9600;      
   }
   else  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
   {       
        A=valeurdudebit[i];
        i++;     
   }
 
   Serial.begin(A);
   lcd.print (A);
   
}

Sur l'écran il y a bien 9600 qui s'affiche mais il est écrit plein de fois à la suite du genre 960096009600.. sur les 2 lignes du lcd

Quand j'appuie sur le bouton poussoir il se passe qqchose mais tout défile à très grande vitesse comme si il affichait toutes les valeurs et quand je le relache sa revient à 9600.

Ce que je veux c'est changer avec ce BP le débit et afficher une seul fois la valeur du débit qui est utilisée sur la ligne du haut du lcd

[invite1d577638]

Relis mon post 143...

Ta boucle loop ne peut pas marcher car tu incrémentes ta variable i tant que ton bouton est enfoncé... Ce qui, couplé à la vitesse d'exécution sur le uc, est très rapide. Il faut que tu procèdes autrement !

[invite4137e186]

Bonjour

après vos conseils voici mon nouveau code :

//*********** Librairies utilisées **********//
#include <LiquidCrystal_I2C.h>
#include <Wire.h>

//***********  Règle la taille du LCD : 16 colonnes et 2 lignes **********//
LiquidCrystal_I2C lcd(0x27, 16, 2);

 const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
  const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
  const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino
   
   //***********  tableau avec les 11 valeurs de débit possible **********//
   float valeurdudebit[11] = {300,1200,2400,4800,9600,14400,19200,28800,38400,57600,115200};
   
   
   int etatBouton1 = 0;         //Variable pour l'état actuel du bouton poussoir 1
   int lastetatBouton1 = 0;     // Variable pour l'état précédent du bouton poussoir 1
   int etatBouton2;
   int etatBouton3;
   
   
void setup() {

  Serial.begin(9600); //Lancer le mode série
  
  // Initialiser l'écran LCD
  lcd.begin();

  // Allumer la lumiére noire : obligé d'être écrit pour faire fonctionner l'écran
  lcd.backlight();

    pinMode(bouton1, INPUT);
    digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton2, INPUT);
    digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    pinMode(bouton3, INPUT);
    digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
    
   // A représente le débit de la carte qui sera afficher sur le lcd
   
 }
        int A;
        int i=0;

void loop()
{

     etatBouton1 = digitalRead(bouton1); //Rappel : bouton1 = 2; lit l'état actuel du bouton poussoir et le mémorise dans la variable
     
     // compare l'état actuel du bouton poussoir à l'état précédent mémorisé
    if (etatBouton1 != lastetatBouton1) {
    
 if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
   {
       A=9600;      
   }
   else  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
   {       
        A=valeurdudebit[i];
        i++;     
        Serial.begin(A);
        lcd.print (A);
   }
 
 
    //mémorise l'état courant du bouton poussoir
    //pour les prochains passages dans la boucle loop
    
       lastetatBouton1 = etatBouton1; 
   
}
}

je pense avoir qqchose de mieux. une fois le programme téléchargé, en haut à gauche de l'écran on voit 300 si j'appuie sur le BP il affiche 3001200 puis après 30012002400 quand je r appui soir les valeurs de mon tableau. je voulais savoir si il est possible qu'il affiche le débit suivant à la place de l'ancien soit au lieu d'afficher à la suite 3001200 se serais plutôt 300 et quand j'appuie il n'y a que 1200 qui s'affiche à la place de 300

[invite1d577638]

Vois si la librairie de pilotage du LCD à une fonction "clear" à exécuter avant le "print".

[invite4137e186]

Bonjour

je sais enfin changer le débit et afficher sur l'écran celui que j'utilise.

Maintenant je dois pouvoir changer la parité et le nombre de bits stop.

je pense que je dois utiliser
SERIAL_5N1
SERIAL_6N1
SERIAL_7N1
SERIAL_8N1 (celui par défaut)
SERIAL_5N2
SERIAL_6N2
SERIAL_7N2
SERIAL_8N2
SERIAL_5E1
SERIAL_6E1
SERIAL_7E1
SERIAL_8E1
SERIAL_5E2
SERIAL_6E2
SERIAL_7E2
SERIAL_8E2
SERIAL_5O1
SERIAL_6O1
SERIAL_7O1
SERIAL_8O1
SERIAL_5O2
SERIAL_6O2
SERIAL_7O2
SERIAL_8O2

C'est à dire que lorsque j'appui sur le bouton je change la parité et sur l'autre bouton je change le nombre de bits stop. Et afficher sur le lcd la parité que j'ai et le nb de bits stop.

Mais là je ne vois pas comment faire, si je dois dire tous les cas possibles.