Bonjour à tous et à toutes,

Récemment j'ai crée une plaque ronde tournante pour présenter mes produits avec un Slider,

Je me suis dit pourquoi pas créer un boitier de contrôle, qui comporterait un menu grâce à un arduino car j'avais déjà quelques connaissances.

Dans ce menu j'aimerais qu'il y ait 2 menus principaux : 1) Plaque tournante

                                                                                  2) Slider

Et avoir des sous-menus au 1) et 2) qui me permettrait d'ajuster la vitesse.

Sous Menus 1): Vitesse 1 | Vitesse 2 | Vitesse 3 qui augmenterait le nombre de pas du moteur pap qui fait tourner la plaque.

Sous Menus 2): Vitesse 1 | Vitesse 2 | Vitesse 3 qui augmenterait la fréquence PWM qui fait fonctionner le slider.

J'ai actuellement besoin d'aide pour le code, j'ai déjà codé quelques programmes mais sans succès.

Merci à tous 

pour commencer il va falloir quelques bouton (genre 4 c'est pas mal) pour contrôler ton interface ^^.

ensuite pour le câblage et le code tu peux t'inspirer de l'exemple Arduino.

// include the library code:
#include <LiquidCrystal.h>

const int button1 = 7, button2 = 8, button3 = 9, button4 = 10;

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup()
{
	pinMode ( button1, input );
	pinMode ( button2, input );
	pinMode ( button3, input );
	pinMode ( button4, input );

	lcd.begin ( 16, 2 );
	lcd.setCursor( 1, 0 );
	lcd.print ( "STEP" );

	lcd.setCursor( 9, 0 );
	lcd.print ( "SLIDE" );

	lcd.setCursor ( 0, 1 );
	lcd.print ( 0 );

	lcd.setCursor ( 8, 1 );
	lcd.print ( 0 );
}

void loop()
{
	int menu = 0;
	unsigned int stepLvl[ 2 ] = { 0 };

	long time1 = 0;
	long time2 = 0;

	if ( digitalRead ( bouton1 ) ||
		digitalReadd ( bouton2 ) )
	{ // switch between pap and slide
		menu ^= 0x01;
		
		lcd.print ( " " );
		lcd.setCursor ( 8 * menu, 0 );
		lcd.print ( "#" );
	}

	if ( digitalRead ( bouton3 ) &&
		!digitalRead ( bouton4 ) )
	{ // reduce step
		if ( !time1 )
		{
			time1 = millis ( );
		}
		else if ( millis () - time1 > 500 )
		{
			time1 = millis ( );
			stepLvl[ menu ]--;

			lcd.setCursor ( 8 * menu, 1 );
			lcd.print ( "        " );

			lcd.setCursor ( 8 * menu, 1 );
			lcd.print ( stepLvl[ menu ] );
		}

	}
	else
	{
		time1 = 0;
	}

	if ( digitalRead ( bouton4 ) &&
		!digitalRead ( bouton3 ) )
	{ // increase step
		if ( !time2 )
		{
			time2 = millis ( );
		}
		else if ( millis () - time2 > 500 )
		{
			time2 = millis ( );
			stepLvl[ menu ]--;

			lcd.setCursor ( 8 * menu, 1 );
			lcd.print ( "        " );

			lcd.setCursor ( 8 * menu, 1 );
			lcd.print ( stepLvl[ menu ] );
		}
	}
	else
	{
		time2 = 0;
	}

	switch ( menu )
	{
		case 0:
		{
			// drive pap motor with stepLvl[ 0 ]
			break;
		}
		case 1:
		{
			// drive slider motor with stepLvl[ 1 ]
			break;
		}
		default:
		{
			break;
		}
	}
}

c'est un début sur lequel tu devrais pouvoir de baser

Me suis amusé avec un menu de configuration à 2 boutons seulement,

• un pour sélectionner l'item à configurer (plaque, slider)
• l'autre pour changer sa valeur  

(avec un shield 16x2 + 4 boutons)

Au debut l'affichage montre

+----------------+
|Pressez un      |
|bouton...       |
+----------------+

en appuyant sur [select], on accède au paramètre plaque

+----------------+
|Plaque > v1     |
|Slider   v2     |
+----------------+

le second bouton [Left] change cycliquement le v1 en v2, v3, v1, ...

le bouton [select] fait passer au paramètre suivant

+----------------+
|Plaque   v1     |
|Slider > v2     |
+----------------+

 avec le même traitement. Select une fois de plus ramène au menu. On y revient aussi automatiquement si on ne touche à rien.

Voila le graphe qui décrit la logique

et le code source (SGDG)

#include <LiquidCrystal.h>

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

int read_LCD_buttons()
{
  int adc_key_in = analogRead(0);      // read the value from the sensor 
  // my buttons when read are centered at these valies: 0, 144, 329, 504, 741
  // we add approx 50 to those values and check to see if we are close
  /*
 if (adc_key_in > 1000) return btnNONE; // We make this the 1st option for speed reasons since it will be the most likely result
   // For V1.1 us this threshold
   if (adc_key_in < 50)   return btnRIGHT;  
   if (adc_key_in < 250)  return btnUP; 
   if (adc_key_in < 450)  return btnDOWN; 
   if (adc_key_in < 650)  return btnLEFT; 
   if (adc_key_in < 850)  return btnSELECT;  
   */
  // For V1.0 comment the other threshold and use the one below:

  if (adc_key_in < 50)   return btnRIGHT;  
  if (adc_key_in < 195)  return btnUP; 
  if (adc_key_in < 380)  return btnDOWN; 
  if (adc_key_in < 555)  return btnLEFT; 
  if (adc_key_in < 790)  return btnSELECT;   

  return btnNONE;  // when all others fail, return this...
}

// ---------------------------------------------------------


const int AUCUN = 0, PLAQUE = 1, SLIDER = 2;
int item = AUCUN;

//                     01234567890123456
char ligne_plaque[] = "Plaque > v1";
char ligne_slider[] = "Slider > v1";

char & temoin_plaque = ligne_plaque[7];
char & temoin_slider = ligne_slider[7];

char & numero_vitesse_plaque = ligne_plaque[10];
char & numero_vitesse_slider = ligne_slider[10];

int choix_vitesse_plaque = 1;
int choix_vitesse_slider = 1;

const int DELAI_EXPIRATION_TOUCHE = 200;
const int DELAI_EXPIRATION_CHOIX = 3000; // retour auto au menu

unsigned long expiration_touche = 0;
unsigned long expiration_choix = 0;

boolean menu_a_jour = false;

void afficher_menu() {

  if (menu_a_jour) return;

  temoin_plaque = (item == PLAQUE) ? '>' : ' ';
  temoin_slider = (item == SLIDER) ? '>' : ' ';
  numero_vitesse_plaque = '0' + choix_vitesse_plaque;
  numero_vitesse_slider = '0' + choix_vitesse_slider;

  lcd.setCursor(0,0);
  lcd.clear();

  if (item == AUCUN) {
    lcd.print("Pressez un");
    lcd.setCursor(0,1);
    lcd.print("bouton...");
  } 
  else {
    lcd.print(ligne_plaque);
    lcd.setCursor(0,1);
    lcd.print(ligne_slider);
  }
  menu_a_jour = true;
}

void appui_bouton_choix_parametre()
{
  item = ((item + 1) % 3);
  menu_a_jour = false;
}

void appui_bouton_choix_valeur()
{
  switch (item) {
  case PLAQUE : 
    choix_vitesse_plaque = choix_vitesse_plaque  % 3 + 1;
    break;
  case SLIDER : 
    choix_vitesse_slider = choix_vitesse_slider  % 3 + 1;
    break;
  default:
    break;
  }
  menu_a_jour = false;
}

void retour_au_menu()
{
  item = AUCUN;
  menu_a_jour = false;
}

void gerer_menu() {
  unsigned long temps = millis();
  int touche = read_LCD_buttons();

  // retour automatique
  if (item != AUCUN && touche == btnNONE && temps > expiration_choix) {
    retour_au_menu();
  }

  if (temps >= expiration_touche) {      // anti-répétition
    switch (touche) {
    case btnSELECT :
      appui_bouton_choix_parametre();
      expiration_touche = temps + DELAI_EXPIRATION_TOUCHE;
      expiration_choix = temps + DELAI_EXPIRATION_CHOIX;
      break;
    case btnLEFT :
      appui_bouton_choix_valeur();
      expiration_touche = temps + DELAI_EXPIRATION_TOUCHE;
      expiration_choix = temps + DELAI_EXPIRATION_CHOIX;
      break;
    };
    afficher_menu();
  }

}

void setup()
{
  lcd.begin(16, 2);              // start the library
  afficher_menu();
}


void loop()
{
  gerer_menu();
}

-
Edité par michelbillaud 22 juillet 2018 à 17:47:15

Merci à tous pour vos réponses mais le problème et que j'ai juste un écran I2C, pas de shield avec boutons.

Après je peux ajouter des boutons mais genre je veux juste un MENU avec deux catégories et 3 sous menus par partie, mais genre j'ai aucune idée de comment commander le menu, si on sélectionne une catégorie, ca affiche la catégorie demandée, puis changer la vitesse.

J'ai vu qu'on peut le faire avec des String[], mais j'ai aucune piste...

"je veux juste", elle est bonne celle-là. Pour les idées, tu peux regarder dans les deux exemples qu'on t'a donné.

Avant de regarder comment faire le programme, il faut que tu décides de ce que tu veux que ton système fasse. Comment l'utilisateur va s'en servir. En détail. Après quand tu sauras combien tu veux mettre de boutons, et comment se passe le dialogue avec l'utilisateur, on pourra voir pour la programmation.

Dans ce que je t'ai donné, ça marche avec deux boutons, qui ne prennent sur le shield qu'une entrée analogique (un pont de résistances). C'est facile de remplacer ça par des boutons connectés de la façon usuelle, une pin pour chaque. C'est pas le vrai problème.

On peut aussi faire avec un seul bouton, en décodant les appuis courts et les appuis longs (comme pour régler les montres).

-
Edité par michelbillaud 18 juillet 2018 à 21:32:10

Bonjour,

Je voudrais utiliser deux boutons, un bouton pour naviguer dans les menus et on autre bouton qui fera office de ENTRER dans les sous menus.

Pour chaque sous-menus des deux catégories, je voudrais trois vitesses, pour le moteur PaP je rentrerai des valeurs de pas précises pour chaque vitesse. Et pour le moteur DC, je vais varier la fréquence PWM pour pouvoir modifier la vitesse.

Je veux que mon système me permette de contrôler mon slider que je vais fabriquer sous peu et ma plaque tournante. Le problème est que je ne sais pas comment faire le menu. Et je n'ai pas de shield, j'ai connecté deux boutons poussoirs avec une résistance de 10Kohms qui fait résistance de pull-down.

Cordialement.

Il te reste à définir l'enchainement des menus et des actions.

A chaque étape, ce que tu veux voir, et ce qui se passe quand tu appuies sur un bouton, ou sur l'autre. Un beau dessin. Indispensable pour avoir les idées claires.

Exemple de question à se poser: avec deux boutons, comment tu reviens d'un sous-menu au menu ?

C'est pour ça que je me suis enquiquiné à te faire un exemple dans le début de mon message du 17/7.

PS: tu peux même te passer de résistances, avec des entrées en pullup.

-
Edité par michelbillaud 19 juillet 2018 à 12:33:43

Donc ce que je peux faire c'est ajouter un troisième bouton Retour.

J'ai fait un petit organigramme

Et pour l'option retour le mieux est de faire comme dans l'organigramme ci-dessous, où juste look à la fin de la loop si le bouton est pressé et on retourne au menu 1. Quel est le plus judicieux ?

Il y a deux flèches "non" qui partent de "afficher sous menu 1"

Pour te simplifier la vie, et avoir une chance de t'y retrouver, tu devrais fixer des conventions visuelles

• fleche verticale pour [suivant]
• horizontale pour [entrer]

ce qui te dispenserait des boites "pression bouton"

Je trouve cela plus claire comme cela, au niveau du code je fais comment ?

Avez-vous une idée ?

Ben, je t'ai donné mon petit dessin, et mon code. Tu dois pouvoir repérer le lien entre les deux.

Le problème c'est que je comprends pas ...

Si tu n'en dis pas plus sur ce que tu sais faire ou pas en programmation, et ce que tu ne comprends pas, on va pas avancer. 

 ---

Sinon, on peut faire avec deux boutons seulement, par exemple ajoutant un item "retour" en bas de chaque sous-menu

Le menu principal afficherait le nom des paramètres de configuration, en montrant leur valeur courante. Ca équivaudrait à un menu de plusieurs lignes, avec défilement par  [suivant].

  Pression : haute
> Vitesse : rapide   <
  Contraste: élevé 
  ...

Si on est sur Vitesse, et qu'on appuie sur [entrer], ça entre dans le menu de choix configuration d'un paramètre. Là on pourrait défiler entre les différentes valeurs possibles, la valeur courante étant mise en évidence. Plus un choix pour le retour

  Vitesse :   lente
> Vitesse :   moyenne   <
  Vitesse :  *rapide 
  [ Retour menu ]

Là aussi, [suivant] navigue entre les valeurs possibles, on se positionne sur celle qu'on veut, et avec [entrer] on change le paramètre pour la valeur sélectionnée, et ça revient au menu.

Bonsoir,

Encore merci de vos réponses.

En temre de codage je me débrouille pas mal, les boucles for, while, variables, constantes...

Mais la je m'attaque à quelque chose de nouveau, je ne sais pas comment m'y prendre...

Voila une autre version, dans l'esprit de ce que racontais plus haut.

Remarques :

• les menus ont été "réifiés", ils sont matérialisés par des structures de données plutôt que par des instructions.
• ça serait mieux si le menu principal faisait défiler les paramètres, avec leur valeur actuelle (qui correspond au setting). Pour faire ça bien, il faudrait 2 classes pour les menus, avec polymorphisme etc : j'ai préféré éviter ça aux ames sensibles.
• pour la même raison, un tableau de menus plutot que des pointeurs.
• le décodage des touches est à repiquer dans le code précédent.
• SET_SPEED et SET_POWER pourraient être ramenés à une seule constant SET_VALUE
• l'indentation s'est barrée en copiant collant.

enum Action {
    SHOW_MAIN_MENU,
    SHOW_SPEED_MENU,
    SHOW_POWER_MENU,
    SET_SPEED,
    SET_POWER,
};
    
struct MenuItem {
    const char * label;
    const Action action;
};

struct Menu {
    const char * title;
    int setting;
    int index;                      // currently displayed 
    const int nb_items;
    const MenuItem *items;

    
    void display() {
	lcd.setCursor(0,0);
	lcd.clear();
	lcd.print(title);
	lcd.setCursor(0,1);
	lcd.print(items[index].label);
	if (index == setting) {
	    lcd.print(" *");	
	}
    }
    
    void next() {
	if (++index == nb_items) {
	    index = 0;
	}
    }
};

enum {
    MAIN_MENU,
    SPEED_MENU,
    POWER_MENU
} current_menu = MAIN_MENU;

Menu menus[] = {
    { "Parameter ?", -1,    //setting unused for main menu
      0,  2, (const MenuItem[]) {
	    { "Speed", SHOW_SPEED_MENU },
	    { "Power", SHOW_POWER_MENU }
	}
    },
    { "Speed =", 0,
      0, 4, (const MenuItem[]) {
	    { "Slow",   SET_SPEED },
	    { "Normal", SET_SPEED },
	    { "Fast",   SET_SPEED },
	    { "[return]", SHOW_MAIN_MENU}
	}
    },
    { "Power = ", 0,
      0, 4, (const MenuItem[]) {
	    { "Low",    SET_POWER },
	    { "Medium", SET_POWER },
	    { "High",   SET_POWER },
	    { "[return]", SHOW_MAIN_MENU }
	}
    }
};

boolean must_redisplay = true;

typedef unsigned long millis_t;

millis_t button_ignored_limit = 0;
const int BUTTON_BOUNCE_DELAY  = 300;

void on_next_button_pressed()
{
    menus[current_menu].next();
}


void on_action_button_pressed()
{
    Menu & m = menus[current_menu];
    
    switch (m.items[m.index].action) {
    case SHOW_MAIN_MENU :
        current_menu = MAIN_MENU;
        break;
    case SHOW_SPEED_MENU :
        current_menu = SPEED_MENU;
        break;
    case SHOW_POWER_MENU :
        current_menu = POWER_MENU;
        break;
    case SET_SPEED :
    case SET_POWER :
        m.setting = m.index;
        current_menu = MAIN_MENU;
        break;
    }   
}

void manage_events() {
  int button = read_LCD_buttons();
  millis_t now = millis();
  if (now >= button_ignored_limit) {      // anti-répétition
    switch (button) {
    case btnSELECT :
         on_next_button_pressed();
         break;
    case btnLEFT :
         on_action_button_pressed();
         break;
    default:
         return;
    };
    must_redisplay = true;
    button_ignored_limit = now + BUTTON_BOUNCE_DELAY;
  }
}

void setup()
{
  lcd.begin(16, 2);  
}

void loop()
{
    if (must_redisplay) {
	menus[current_menu].display();
	must_redisplay = false;
    }
    manage_events();

}

-
Edité par michelbillaud 25 juillet 2018 à 14:09:32

Bonjour,

Je cherche à faire quelque chose dans ce style là.

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

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

const int boutonSuivant = 2;
const int boutonEntrer = 3;

int MenuPos = 1;
int SousMenuPos = 0;
int etatboutons = 0;

void setup() {
  pinMode(boutonSuivant, INPUT);
  pinMode(boutonEntrer, INPUT);
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Loading...");
  delay(2500);
  lcd.clear();
  Serial.begin(9600);

}

void loop() {
  etatboutons = digitalRead(boutonSuivant);
  
  if(etatboutons == HIGH){
    int MenuPos = MenuPos+1;
      if(MenuPos > 2){
        int MenuPos = 1;
      }
  }
  Serial.println(MenuPos);
  void AffichageMenu();
}

void AffichageMenu(){
  
  if(MenuPos == 1){
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Menu #1");
  }

  if(MenuPos == 2){
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Menu #2");
  }
}

Il y a un petit problème ligne 36, qui fait que  ton programme ne doit pas compiler, et encore moins s'exécuter.

Problème aussi aussi avec la consultation des boutons

• il y en qu'un de testé
• il est testé trop rapidement ce qu'il fait que le menu change plusieurs dizaines/centaines de fois par seconde
• tu as du constater que l'affichage était très instable

Première chose à faire : ne pas essayer de tout faire d'un coup. Se donner un objectif partiel: déjà, si  un bouton alternait de façon fiable entre deux choix, ça serait un bon début. Le rôle du second bouton, plus tard.

Pour le second problème, une solution est de se dire que, quand on a détecté que le bouton passait à HIGH, il ne faut plus le regarder pendant un certain temps, par exemple 3/10 seconde.

Pour faire ça on utilise

• la fonction millis() qui dit "l'heure qu'il est" en millisecondes depuis le démarrage
• une variable qui dit à partir de quelle heure on peut regarder la touche la prochaine fois

// variable globale
unsigned long prochaine_consultation = 0;


void loop() 
{
     unsigned long temps = millis();
     if (temps >= prochaine_consultation) {   // c'est l'heure ?
         if (digitalRead(bouton) == HIGH) {
              ....
              prochaine_consultation = temps + 300;
         }
     }
     ....
}

-
Edité par michelbillaud 22 juillet 2018 à 17:50:16

Hello,

Tel qu'écrit là,  tu as 3 variables MenuPos différentes: elles sont déclarées en lignes 9, 30 et 32.... tu dois supprimer les int aux lignes 30 et 32.

-
Edité par edgarjacobs 22 juillet 2018 à 18:20:50

Ok là je suis parti en vacances, je reviens d’ici 12jours je vous donnerai des nouvelles, merci beaucoup je teste tout ca en rentrant

Donc la grace au code j'arrive à avoir, MenuPos = 1 ou MenuPos = 2,

Or rien ne s'affiche des idées ?

Et comment je peux faire pour avoir des sous menus ?

Genre si MenuPos = 1

Plaque tournante (MenuPos = 1)

Vitesse1 (MenuSousPos = 1)

Vitesse2 (MenuSousPos = 2)

Vitesse3 (MenuSousPos = 3)

Si vous avez des codes pour avoir un menu simple je suis preneur.

Merci

C'est payė combien ?

Vous parlez de ?

Léo A. a écrit:

Vous parlez de ?

Léo A. a écrit:

Si vous avez des codes pour avoir un menu simple je suis preneur.

Ben, tout travail mérite salaire. Si quelqu'un doit écrire le code à ta place, il est normal qu'il soit rémunéré.

Maintenant, te donner un coup de main pour t'aider à corriger le code que tu as écrit, ça c'est autre chose.

-
Edité par edgarjacobs 8 août 2018 à 19:02:14

Et le code qu'on t'a déjà filé, tu en as fait quoi?

Bonjour et merci des reponses,

Michel Billaud je ne comprends rien au code que vous m'avez donné. Et je m'en excuse, où est la void setup ?

Edgar je suis venu ici pour chercher de l'aide pour construire un code et non payé des personnes pour qu'elle me le fasse, mon but est de le coder et de le comprendre.

Cordialement

Léo 

Michel Billaud je ne comprends rien au code que vous m'avez donné. Et je m'en excuse, où est la void setup ?

Ligne 125 dans le message du 22 juillet.

Ligne 136 dans celui du 17.

Forcément, si on voit pas les déclarations de fonctions, on peut avoir du mal à comprendre le code.

-
Edité par michelbillaud 11 août 2018 à 23:08:57

Le problème est que je ne comprends pas comment fonctionne le code, en entier, je ne comprends absolument rien, vous ne connaissez pas une autre alternative ?

Léo A. a écrit:

Le problème est que je ne comprends pas comment fonctionne le code, en entier, je ne comprends absolument rien, vous ne connaissez pas une autre alternative ?

Deux alternatives raisonnables :

• apprendre à programmer. Au moins essayer de comprendre.
• payer quelqu'un pour le faire.

sinon, attendre un programme tout fait qui passerait dans le ciel par hasard, ça risque pas trop.

Une autre solution : trouver dans son entourage une personne qui sait programmer un Arduino et que le projet amuse.

-
Edité par michelbillaud 14 août 2018 à 14:16:37

Ok merci