C et tableau, enum etc..

[hary]

enfin l'action à effectuer sur l'equipement en fonction du niveau de batterie, si j'ai compris ton besoin:

void action (struct equipement_t* equip, enum niveau_bat_t niveau) {
    if (niveau < equip->coupe) {
        equip->relais = 0; // couper l'equipement
    } else if ((niveau < equip->inhibe) && (equip->contact == 0)) {
        // l'equipement ne fonctionne pas, l'empecher de démarre
        equip->relais = 0; // couper l'equipement
    }

Voilà une voie possible...[/QUOTE]

Dans ce bout de code, le "*" concerne t-il une histoire de pointeur ?
-----

[Chanur]

je ne vois pas de différences entre long et float qui apparemment sont tous les 2 pour les nombres à virgule ?

Non, pas du tout. "long" est un entier et "float" un nombre à virgule flottante.

Et ça fait une grosse différence dans les calculs, notamment quand on fait des divisions. Par exemple, l'expression "UPONT * Vcc /1024" n'étant composée que de nombres entiers donne un nombre entier. Même si ensuite tu mets le résultat dans un float. (si UPONT * Vcc /1024 vaut 0.9, le résultat versé dans tension_de_pont sera 0).

[lou_ibmix_xi]

Je te laisse méditer sur la réponse de Chanur, mais si faire la conversion dans une fonction ne te donne pas le même résultat que le même code appelé dans le "main", c'est que tu as fais une erreur (type de retour de la fonction, type de la variable dans laquelle tu mets la valeur de retour de ta fonction...)

Dans ce bout de code, le "*" concerne t-il une histoire de pointeur ?

Oui, c'est une notion indispensable en C, le but ici est double:
- c'est nécessaire si tu veux que les modifications d'un ou plusieurs champ de ta structure survivent après le retour de ta fonction
- alleger le cout de l'appelle de la fonction
En effet, les arguments d'une fonction sont copiés dans la pile C, ie.e la fonction travaille avec une copie de ce que tu lui as passé en argument, et si tu ne passes pas l'adresse de ta structure mais ta structure directement, il faut empiler (puis dépiler) toute la structure plutôt que juste une adresse.

Avec mon Arduino, j'étais un peu bloqué au clan... Arduino! Mais il faut dire que c'est une bon tremplin d'accès je pense.

Pas forcément, si je me rappelle bien, tout est ouvert avec ARDUINO, donc tu devrais pouvoir facilement l'utiliser avec du vrai C et GCC... De plus tout dépends ce que tu cherches, si tu veux apprendre le C embarqué pour apprendre le C embarqué, arduino n'est en effet qu'un tremplin. En revanche si c'est juste pour bricoler tes projets personnels, je pense qu'il est inutile de te lancer de cet apprentissage, l'arduino me semble complètement remplir cette niche.

Pour l'instant j'ai un peu de mal à saisir l'intérêt de l'embarqué avec OS. A la base, je pensais que l'embarqué étais du sans OS !
Pour moi, l'adjonction d'un OS ne facilita pas la chose. Je ne suis pas plus à l'aise sous LINUX !

J'avoue que j'ai bien du mal à donner une définition précise de l'informatique embarquée...
Sur un projet non trivial, un OS facilite toujours le développement car:
- il offre des "services" comme le multi-tâche et de quoi les synchronisés
- il offre une séparation entre les espaces d'adressages, chaque programme qui tourne ne verra pas l'espace d'adressage de son voisin, et donc il ne pourra pas le faire crasher en allant écraser une variable quelconque, l'OS s'interpose (le fameux SEGFAULT)
Seulement, un OS est un programme plus ou moins complexe en soit, qui nécessite donc une certaine gamme de CPU, donc un prix et une consommation énergétique associée. Si on ne peut pas se permettre ce surcoût, on utilise des "pseudo OS" comme FreeRTOS, vois on se passe d'OS.
La moitié des systèmes embarqués que je met en place dans mon boulot utilises linux comme OS, et sur des machines assez modestes comme ça par exemple, et tu peux le faire tourner sur nettement plus léger... D'ailleur, historiquement UNIX a été développé pour les ordinateurs des années 70 où la 100aine de ko de mémoire devait être un luxe...
Si tu n'es pas à l'aise pour l'instant sous linux ou ailleurs c'est vraissemblablement parce que tu n'es pas à l'aise avec la syntaxe du C.

[hary]

Merci pour tes réponses toujours très fournies !

Je suis actuellement sur les pointeurs, tableaux, structures justement. Je continu dans la voie du C et tes explications ne m'invitent qu'à persister !

Certes, j'aurai pu rester à l'Arduino qui est tout à fait extraordinaire pour moi qui souhaite bricoler. Le soucis, c'est que pour évoluer, il faut comprendre et lire le code des autres. Or, les autres, ceux qui connaissent, ceux qui y tatent un peu, ils programment en C, utilisent les opérateurs bit à bit, et utilisent plein d'écritures propres au C "for( ; ; )", "PORTB |= (1<<5);"

Donc si j'en ai pas au moins les bases, je suis incapable de comprendre quoique ce soit !
L'apprentissage du C est donc indispensable pour moi.

En plus, l'informatique me mène la vie dure et je ne supporte plus de ne pas comprendre. Tu viens de rajouter une raison de plus au fait que je ne suis pas apte à passer à LINUX ! Il me manque la syntaxe du C !
Si la maitrise du C permet de passer plus facilement à LINUX, alors, cette unique raison serait presque suffisante pour persister.
En plus, je sens la frontière entre embarqué sans OS et embarqué avec OS s'estomper. RTOS, LINUX embarqué... tout ça, je sens que j'ai des trucs à prendre la dedans !

Mais comme pour le moment je dois juste piloter quelques pins en sortie et gérer quelques entrées analogiques, mes petits Arduino me vont bien. En plus, ça aidera à comprendre ce qui ce passe même si je passe à du système avec OS embarqué.

Je crois que tout ça se tient et est assez cohérent.

La seule chose pénible est que je dois délaisser temporairement mon petit projet pour me concentrer un peu sur le C !

[Jack]

Même si langage C et UNIX sont historiquement liés, je ne vois pas trop en quoi l'utilisation de l'un dépend de la syntaxe de l'autre. On peut très bien programmer en C toute sa vie sans utiliser le moindre OS dérivé d'UNIX. Inversement, il est possible de faire de l'administration réseau sous linux par exemple sans avoir besoin d'écrire une ligne de C.

A+

[hary]

Je pense qu'il y a des similitudes dans la "syntaxe" ou la mise en oeuvre.
Des principes de raisonnement..

J'en ai eu l'impression au travers de mes quelques tentatives.

Je pense que c'est ce à quoi faisait référence lou_ibmix_xi

En tout cas, la pratique de l'un facilite la pratique de l'autre et vice versa peut être.

[Jack]

Tu as des exemples de similitude?

[hary]

Non désolé.
Mais peut être que les simples appels à des terminologies et abréviations anglo-saxonne donnent cette impression !

[lou_ibmix_xi]

En plus, l'informatique me mène la vie dure et je ne supporte plus de ne pas comprendre. Tu viens de rajouter une raison de plus au fait que je ne suis pas apte à passer à LINUX ! Il me manque la syntaxe du C !
Si la maitrise du C permet de passer plus facilement à LINUX, alors, cette unique raison serait presque suffisante pour persister.

J'ai du mal m'exprimer donc désolé pour la fausse joie, mais le C ne t'avancera en rien pour âtre à l'aise dans l'utilisation d'un système linux...
Après tout dépends, pour l'utilsation quotidienne, tu te sentiras à l'aise une fois que tu auras "refait" les reflexes acquis sous windows, ce n'est pas plus compliqué, c'est juste différent. Pour une administration un peu plus poussé, 1°) ça me semble plus facile et cohérent que sous windows (mais ce n'est que mon point de vu), 2°) ça ne concerne pas grand monde (qui installe un serveur SSH et autre sendmail chez lui?). Pour des bricoleurs comme tu sembles en être un, il me semble que c'est _LE_ système d'exploitation le plus adéquat car tu peux le bricoler dans tous les sens _ET_ c'est un UNIX qui permet d'avoir "flux de travail" efficace et pas chère...

Je pense que c'est ce à quoi faisait référence lou_ibmix_xi
En tout cas, la pratique de l'un facilite la pratique de l'autre et vice versa peut être.

Ce n'est donc pas ce que je voulais dire! Mais tout dépends de quelle informatique nous parlons... Je suis basiquement d'accord avec Jack, comprendre le C (ou n'importe quel autre langage de programmation) ne t'apportera rien dans l'informatique quotidienne... Je ne compte plus les gens deçus par mon incompétence lorsque je dois leur "réparrer" leur ordinateur sous windows...

En revanche, il y a tout de même des connexions "historico-conceptuelles":
- la philosophie UNIX doit s'appliquer dans la conception de ton programme en aggrégeant des sous-programmes, de ton système en aggrégeant des programmes...
- il y a parallèle interfaces systèmes / interface de programmation
- un système UNIX est un merveilleux outils pour automatiser tout un tas de tâches inhérentes au travail du développeur

[hary]

Bon, après avoir passé un peu de temps dans la théorie des pointeurs, tableaux, structure, j'ai la tête farcie !

Je pensais être un peu plus armé pour m'attaquer à quelque chose qui me tient à coeur qui serait de faire un menu sur un LCD accessible par bouton poussoir pour voir mes tensions, intensité et puissance, et aussi pour modifier mes seuil de tension au travers de ce menu pour ne plus avoir besoin de reprogrammer le uC avec un PC.

Je pense avoir trouvé des exemples très intéressant mais dont la compréhension est bien au delà de mes compétences.
J'ai mis tout le code dans Notepad++ pour avoir de la couleur et une mise en page agréable, mais même comme ça, j'ai les yeux qui piquent !

Je ne sais pas si il y à une méthode pour aborder ce type de code un peu long qui fait appel à plein de fonctions et notions que je ne connais pas ou ne maitrise pas.

Voici le code qui m’intéresserait de pouvoir comprendre et utiliser.

/*
||
|| @file 	MenuBackend.h
|| @version 1.4
|| @author 	Alexander Brevig
|| @contact alexanderbrevig@gmail.com
|| @contribution Adrian Brzezinski adrb@wp.pl, http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?action=viewprofile;username=vzhang
||
|| @description
|| | Provide an easy way of making menus
|| #
||
|| @license
|| | This library is free software; you can redistribute it and/or
|| | modify it under the terms of the GNU Lesser General Public
|| | License as published by the Free Software Foundation; version
|| | 2.1 of the License.
|| |
|| | This library is distributed in the hope that it will be useful,
|| | but WITHOUT ANY WARRANTY; without even the implied warranty of
|| | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
|| | Lesser General Public License for more details.
|| |
|| | You should have received a copy of the GNU Lesser General Public
|| | License along with this library; if not, write to the Free Software
|| | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
|| #
||
*/

#ifndef MenuBackend_h
#define MenuBackend_h

/*
	A menu item will be a container for an item that is a part of a menu
	Each such item has a logical position in the hierarchy as well as a text and maybe a mnemonic shortkey
*/
class MenuItem {
public:
	MenuItem(const char* itemName, char shortKey='\0' ) : name(itemName), shortkey(shortKey) {
		before = right = after = left = 0;
	}

	//void use(){} //update some internal data / statistics
	inline const char* getName() const { return name; }
	inline const char getShortkey() const { return shortkey; }
	inline const bool hasShortkey() const { return (shortkey!='\0'); }
	inline void setBack(MenuItem *b) { back = b; }
	inline MenuItem* getBack() const { return back; }
	inline MenuItem* getBefore() const { return before; }
	inline MenuItem* getRight() const { return right; }
	inline MenuItem* getAfter() const { return after; }
	inline MenuItem* getLeft() const { return left; }

	MenuItem *moveBack() { return back; }

	MenuItem *moveUp() { 
		if (before) { before->back = this; }
		return before; 
	}

	MenuItem *moveDown() { 
		if (after) { after->back = this; }
		return after; 
	}

	MenuItem *moveLeft() { 
		if (left) { left->back = this; }
		return left; 
	}

	MenuItem *moveRight() { 
		if (right) { right->back = this; }
		return right; 
	}

	//default vertical menu
	MenuItem &add(MenuItem &mi) { return addAfter(mi); }

	MenuItem &addBefore(MenuItem &mi) {
		mi.after = this;
		before = &mi;
		if ( !mi.back ) mi.back = back;
		return mi;
	}
	MenuItem &addRight(MenuItem &mi) {
		mi.left = this;
		right = &mi;
		if ( !mi.back ) mi.back = back;
		return mi;
	}
	MenuItem &addAfter(MenuItem &mi) {
		mi.before = this;
		after = &mi;
		if ( !mi.back ) mi.back = back;
		return mi;
	}
	MenuItem &addLeft(MenuItem &mi) {
		mi.right = this;
		left = &mi;
		if ( !mi.back ) mi.back = back;
		return mi;
	}
protected:

	const char* name;
	const char shortkey;

	MenuItem *before;
	MenuItem *right;
	MenuItem *after;
	MenuItem *left;
	MenuItem *back;
};

//no dependant inclusion of string or cstring
bool menuTestStrings(const char *a, const char *b) {
	while (*a) { if (*a != *b) { return false; } b++; a++; }
	return true;
}
bool operator==(MenuItem &lhs, char* test) {
	return menuTestStrings(lhs.getName(),test);
}
bool operator==(const MenuItem &lhs, char* test) {
	return menuTestStrings(lhs.getName(),test);
}
bool operator==(MenuItem &lhs, MenuItem &rhs) {
	return menuTestStrings(lhs.getName(),rhs.getName());
}
bool operator==(const MenuItem &lhs, MenuItem &rhs) {
	return menuTestStrings(lhs.getName(),rhs.getName());
}

struct MenuChangeEvent {
	const MenuItem &from;
	const MenuItem &to;
};

struct MenuUseEvent {
	const MenuItem &item;
};

typedef void (*cb_change)(MenuChangeEvent);
typedef void (*cb_use)(MenuUseEvent);

class MenuBackend {
public:

	MenuBackend(cb_use menuUse, cb_change menuChange = 0) : root("MenuRoot") {
		current = &root;
		cb_menuChange = menuChange;
		cb_menuUse = menuUse;
	}

	MenuItem &getRoot() {
		return root;
	}
	MenuItem &getCurrent() {
		return *current;
	}

	void moveBack() {
		setCurrent(current->getBack());
	}

	void moveUp() {
		setCurrent(current->moveUp());
	}

	void moveDown() {
		setCurrent(current->moveDown());
	}

	void moveLeft() {
		setCurrent(current->moveLeft());
	}

	void moveRight() {
		setCurrent(current->moveRight());
	}

	void use(char shortkey)
	{
		recursiveSearch(shortkey,&root);
		use();
	}
	
	void use() {
		//current->use();
		if (cb_menuUse) {
			MenuUseEvent mue = { *current };
			cb_menuUse(mue);
		}
	}
void toRoot() {
  setCurrent( &getRoot() );
    }

private:
	void setCurrent( MenuItem *next ) {
		if (next) {
			if (cb_menuChange) {
				MenuChangeEvent mce = { *current, *next };
				(*cb_menuChange)(mce);
			}
			current = next;
		}
	}
	void foundShortkeyItem(MenuItem *mi) {
		mi->setBack(current);
		current = mi;
	}
	char canSearch(const char shortkey, MenuItem *m) {
		if (m==0) { return 0; }
		else  {
			if (m->getShortkey()==shortkey) {
				foundShortkeyItem(m);
				return 1;
			}
			return -1;
		}
	}
	void rSAfter(const char shortkey, MenuItem *m) {
		if (canSearch(shortkey,m)!=1) {
			rSAfter(shortkey, m->getAfter());
			rSRight(shortkey, m->getRight());
			rSLeft(shortkey, m->getLeft());
		}
	}
	void rSRight(const char shortkey, MenuItem *m) {
		if (canSearch(shortkey,m)!=1) {
			rSAfter(shortkey, m->getAfter());
			rSRight(shortkey, m->getRight());
			rSBefore(shortkey, m->getBefore());
		}
	}
	void rSLeft(const char shortkey, MenuItem *m) {
		if (canSearch(shortkey,m)!=1) {
			rSAfter(shortkey, m->getAfter());
			rSLeft(shortkey, m->getLeft());
			rSBefore(shortkey, m->getBefore());
		}
	}
	void rSBefore(const char shortkey, MenuItem *m) {
		if (canSearch(shortkey,m)!=1) {
			rSRight(shortkey, m->getRight());
			rSLeft(shortkey, m->getLeft());
			rSBefore(shortkey, m->getBefore());
		}
	}
	void recursiveSearch(const char shortkey, MenuItem *m) {
		if (canSearch(shortkey,m)!=1) {
			rSAfter(shortkey, m->getAfter());
			rSRight(shortkey, m->getRight());
			rSLeft(shortkey, m->getLeft());
			rSBefore(shortkey, m->getBefore());
		}
	}
	
	MenuItem root;
	MenuItem *current;

	cb_change cb_menuChange;
	cb_use cb_menuUse;
};

#endif/*

[hary]

Ici le reste du code, tout ne passait pas sur un seul message limité à 18000 caractères !

Copyright Giuseppe Di Cillo (www.coagula.org)
    Contact: dicillo@coagula.org
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/*
IMPORTANT: to use the menubackend library by Alexander Brevig download it at http://www.arduino.cc/playground/uploads/Profiles/MenuBackend_1-4.zip and add the next code at line 195
	void toRoot() {
		setCurrent( &getRoot() );
	}
*/
#include "MenuBackend.h"    //MenuBackend library - copyright by Alexander Brevig
#include <LiquidCrystal.h>  //this library is included in the Arduino IDE

const int buttonPinLeft = 8;      // pin for the Up button
const int buttonPinRight = 9;    // pin for the Down button
const int buttonPinEsc = 10;     // pin for the Esc button
const int buttonPinEnter = 11;   // pin for the Enter button

int lastButtonPushed = 0;

int lastButtonEnterState = LOW;   // the previous reading from the Enter input pin
int lastButtonEscState = LOW;   // the previous reading from the Esc input pin
int lastButtonLeftState = LOW;   // the previous reading from the Left input pin
int lastButtonRightState = LOW;   // the previous reading from the Right input pin


long lastEnterDebounceTime = 0;  // the last time the output pin was toggled
long lastEscDebounceTime = 0;  // the last time the output pin was toggled
long lastLeftDebounceTime = 0;  // the last time the output pin was toggled
long lastRightDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 500;    // the debounce time

// LiquidCrystal display with:
// rs on pin 7
// rw on ground
// enable on pin 6
// d4, d5, d6, d7 on pins 5, 4, 3, 2
//LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

/*LiquidCrystal(rs, enable, d4, d5, d6, d7)
LiquidCrystal(rs, rw, enable, d4, d5, d6, d7)
LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)
LiquidCrystal(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7) */
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);


//Menu variables
MenuBackend menu = MenuBackend(menuUsed,menuChanged);
//initialize menuitems
    MenuItem menu1Item1 = MenuItem("Item1");
      MenuItem menuItem1SubItem1 = MenuItem("Item1SubItem1");
      MenuItem menuItem1SubItem2 = MenuItem("Item1SubItem2");
    MenuItem menu1Item2 = MenuItem("Item2");
      MenuItem menuItem2SubItem1 = MenuItem("Item2SubItem1");
      MenuItem menuItem2SubItem2 = MenuItem("Item2SubItem2");
      MenuItem menuItem3SubItem3 = MenuItem("Item2SubItem3");
    MenuItem menu1Item3 = MenuItem("Item3");


void setup()
{
  pinMode(buttonPinLeft, INPUT);
  pinMode(buttonPinRight, INPUT);
  pinMode(buttonPinEnter, INPUT);
  pinMode(buttonPinEsc, INPUT);
  
  lcd.begin(16, 2);

  //configure menu
  menu.getRoot().add(menu1Item1);
  menu1Item1.addRight(menu1Item2).addRight(menu1Item3);
  menu1Item1.add(menuItem1SubItem1).addRight(menuItem1SubItem2);
  menu1Item2.add(menuItem2SubItem1).addRight(menuItem2SubItem2).addRight(menuItem3SubItem3);
  menu.toRoot();
  lcd.setCursor(0,0);  
  lcd.print("www.coagula.org");

}  // setup()...


void loop()
{

  readButtons();  //I splitted button reading and navigation in two procedures because 
  navigateMenus();  //in some situations I want to use the button for other purpose (eg. to change some settings)
                  
} //loop()... 


void menuChanged(MenuChangeEvent changed){
  
  MenuItem newMenuItem=changed.to; //get the destination menu
  
  lcd.setCursor(0,1); //set the start position for lcd printing to the second row
  
  if(newMenuItem.getName()==menu.getRoot()){
      lcd.print("Main Menu       ");
  }else if(newMenuItem.getName()=="Item1"){
      lcd.print("Item1           ");
  }else if(newMenuItem.getName()=="Item1SubItem1"){
      lcd.print("Item1SubItem1");
  }else if(newMenuItem.getName()=="Item1SubItem2"){
      lcd.print("Item1SubItem2   ");
  }else if(newMenuItem.getName()=="Item2"){
      lcd.print("Item2           ");
  }else if(newMenuItem.getName()=="Item2SubItem1"){
      lcd.print("Item2SubItem1   ");
  }else if(newMenuItem.getName()=="Item2SubItem2"){
      lcd.print("Item2SubItem2   ");
  }else if(newMenuItem.getName()=="Item2SubItem3"){
      lcd.print("Item2SubItem3   ");
  }else if(newMenuItem.getName()=="Item3"){
      lcd.print("Item3           ");
  }
}

void menuUsed(MenuUseEvent used){
  lcd.setCursor(0,0);  
  lcd.print("You used        ");
  lcd.setCursor(0,1); 
  lcd.print(used.item.getName());
  delay(3000);  //delay to allow message reading
  lcd.setCursor(0,0);  
  lcd.print("www.coagula.org");
  menu.toRoot();  //back to Main
}


void  readButtons(){  //read buttons status
  int reading;
  int buttonEnterState=LOW;             // the current reading from the Enter input pin
  int buttonEscState=LOW;             // the current reading from the input pin
  int buttonLeftState=LOW;             // the current reading from the input pin
  int buttonRightState=LOW;             // the current reading from the input pin

  //Enter button
                  // read the state of the switch into a local variable:
                  reading = digitalRead(buttonPinEnter);

                  // check to see if you just pressed the enter button 
                  // (i.e. the input went from LOW to HIGH),  and you've waited 
                  // long enough since the last press to ignore any noise:  
                
                  // If the switch changed, due to noise or pressing:
                  if (reading != lastButtonEnterState) {
                    // reset the debouncing timer
                    lastEnterDebounceTime = millis();
                  } 
                  
                  if ((millis() - lastEnterDebounceTime) > debounceDelay) {
                    // whatever the reading is at, it's been there for longer
                    // than the debounce delay, so take it as the actual current state:
                    buttonEnterState=reading;
                    lastEnterDebounceTime=millis();
                  }
                  
                  // save the reading.  Next time through the loop,
                  // it'll be the lastButtonState:
                  lastButtonEnterState = reading;
                  

    //Esc button               
                  // read the state of the switch into a local variable:
                  reading = digitalRead(buttonPinEsc);

                  // check to see if you just pressed the Down button 
                  // (i.e. the input went from LOW to HIGH),  and you've waited 
                  // long enough since the last press to ignore any noise:  
                
                  // If the switch changed, due to noise or pressing:
                  if (reading != lastButtonEscState) {
                    // reset the debouncing timer
                    lastEscDebounceTime = millis();
                  } 
                  
                  if ((millis() - lastEscDebounceTime) > debounceDelay) {
                    // whatever the reading is at, it's been there for longer
                    // than the debounce delay, so take it as the actual current state:
                    buttonEscState = reading;
                    lastEscDebounceTime=millis();
                  }
                  
                  // save the reading.  Next time through the loop,
                  // it'll be the lastButtonState:
                  lastButtonEscState = reading; 
                  
                     
   //Down button               
                  // read the state of the switch into a local variable:
                  reading = digitalRead(buttonPinRight);

                  // check to see if you just pressed the Down button 
                  // (i.e. the input went from LOW to HIGH),  and you've waited 
                  // long enough since the last press to ignore any noise:  
                
                  // If the switch changed, due to noise or pressing:
                  if (reading != lastButtonRightState) {
                    // reset the debouncing timer
                    lastRightDebounceTime = millis();
                  } 
                  
                  if ((millis() - lastRightDebounceTime) > debounceDelay) {
                    // whatever the reading is at, it's been there for longer
                    // than the debounce delay, so take it as the actual current state:
                    buttonRightState = reading;
                   lastRightDebounceTime =millis();
                  }
                  
                  // save the reading.  Next time through the loop,
                  // it'll be the lastButtonState:
                  lastButtonRightState = reading;                  
                  
                  
    //Up button               
                  // read the state of the switch into a local variable:
                  reading = digitalRead(buttonPinLeft);

                  // check to see if you just pressed the Down button 
                  // (i.e. the input went from LOW to HIGH),  and you've waited 
                  // long enough since the last press to ignore any noise:  
                
                  // If the switch changed, due to noise or pressing:
                  if (reading != lastButtonLeftState) {
                    // reset the debouncing timer
                    lastLeftDebounceTime = millis();
                  } 
                  
                  if ((millis() - lastLeftDebounceTime) > debounceDelay) {
                    // whatever the reading is at, it's been there for longer
                    // than the debounce delay, so take it as the actual current state:
                    buttonLeftState = reading;
                    lastLeftDebounceTime=millis();;
                  }
                  
                  // save the reading.  Next time through the loop,
                  // it'll be the lastButtonState:
                  lastButtonLeftState = reading;  

                  //records which button has been pressed
                  if (buttonEnterState==HIGH){
                    lastButtonPushed=buttonPinEnter;

                  }else if(buttonEscState==HIGH){
                    lastButtonPushed=buttonPinEsc;

                  }else if(buttonRightState==HIGH){
                    lastButtonPushed=buttonPinRight;

                  }else if(buttonLeftState==HIGH){
                    lastButtonPushed=buttonPinLeft;

                  }else{
                    lastButtonPushed=0;
                  }                  
}

void navigateMenus() {
  MenuItem currentMenu=menu.getCurrent();
  
  switch (lastButtonPushed){
    case buttonPinEnter:
      if(!(currentMenu.moveDown())){  //if the current menu has a child and has been pressed enter then menu navigate to item below
        menu.use();
      }else{  //otherwise, if menu has no child and has been pressed enter the current menu is used
        menu.moveDown();
       } 
      break;
    case buttonPinEsc:
      menu.toRoot();  //back to main
      break;
    case buttonPinRight:
      menu.moveRight();
      break;      
    case buttonPinLeft:
      menu.moveLeft();
      break;      
  }
  
  lastButtonPushed=0; //reset the lastButtonPushed variable
}

[Jack]

Houlà, c'est du C++ çà. Et de la programmation objet, qui plus est.

Restes-en au C, pour les projets qui t'intéressent, c'est amplement suffisant.

A+

[hary]

Du C++ ?

Je savais pas que Arduino pouvait ingurgiter du C++ !

Ok, mais je fais comment pour mon menu ?
Ça a pas l'air facile à mettre en œuvre un simple menu !

C'est dommage, étudier un sujet dont j'ai besoin aurait été d'autant plus stimulant !

Mais en effet, il y a des mot réservés qui se colorise quand je pass du C au C++

Je comprend un peu pourquoi j'étais perdu !

[Jack]

Je savais pas que Arduino pouvait ingurgiter du C++

Un microcontroleur n'ingurgite pas du C++, il ne connait que le code machine. Après, que ce qui a permis de fabriquer ce code machine vienne d'un assembleur, d'un compilateur C, C++, d'un interpréteur basic, python ou autre, peu importe.

[lou_ibmix_xi]

Du C++ ?

Je savais pas que Arduino pouvait ingurgiter du C++ !

je déconseille fortement le C++

Ça a pas l'air facile à mettre en œuvre un simple menu !

C'est simple à mettre en oeuvre parce qu'une bibliothèque existe!

C'est dommage, étudier un sujet dont j'ai besoin aurait été d'autant plus stimulant !

regarde les sources de la bibliothèque (si tu es bien sûr qu'elle est compatible avec ton écran LCD), et réécrie la en C, les manipulations des registres et autres bits devrait être reconaissable, la syntaxe du C++ c'est un patchwork de langages collés autour de la syntaxe du C.

[hary]

Oui, j'ai fait un raccourci mais on peut penser à l'IDE Arduino.

Lui, je ne pense pas qu'il prenne du Python.

Mais apparemment, du C++ est ok.

[hary]

regarde les sources de la bibliothèque (si tu es bien sûr qu'elle est compatible avec ton écran LCD), et réécrie la en C, les manipulations des registres et autres bits devrait être reconaissable, la syntaxe du C++ c'est un patchwork de langages collés autour de la syntaxe du C.

Je me sens bien incapable de comprendre et réécrire quoi que ce soit concernant ce que j'ai posté plus haut.

Justement, j'ai trouvé d'autres choses et suis en train de les étudier.

[Jack]

Oui, j'ai fait un raccourci mais on peut penser à l'IDE Arduino.

Lui, je ne pense pas qu'il prenne du Python.

A part un problème de mémoire, rien n'empêcherait d'embarquer un interpréteur python dans un arduino.

Mais apparemment, du C++ est ok.

le langage de programmation pour arduino n'est pas du C++

[hary]

A part un problème de mémoire, rien n'empêcherait d'embarquer un interpréteur python dans un arduino.

Je ne comprend pas. La platine Arduino ne voit que du "compilé" et se fiche de ce qu'il y a avant ! Seul l'IDE Arduino serait capable d'avoir un interpréteur Python ou C++ et à partir de ça fabriquer le compilé à destination de la platine uC. Ce n'est pas celà ?

le langage de programmation pour arduino n'est pas du C++

Sans doute, mais alors il y a un interpréteur C++ puisque queand je lui met le programme de menu dont j'ai parlé plus haut, ça compile et upload !

ou alors je n'ai rien compris du tout !

[Jack]

Je pense que tu n'as pas bien saisi la différence entre un compilateur et un interpréteur. Un compilateur transforme une fois pour toute un fichier écrit dans un langage quelconque en code machine destiné à être exécuté par un processeur. Le compilateur est donc un programme qui peut se trouver ou non sur la machine cible.

Un interpréteur est un programme qui se trouve forcément sur la machine cible et qui convertit au fur et à mesure les lignes de programmes écrites dans un langage quelconque. Rien n'empêche donc quelqu'un d'écrire un interpréteur qui resterait résidant dans l'arduino et qui exécuterait le programme source qu'on lui aurait envoyé.

[Chanur]

Et pour compléter ce que dit Jack,

Exemples de langages compilés :
C, C++, Fortran, Pascal, ...

Exemples de langages interprétés :
Python, Java, VisualBasic, C#, ...

Et sinon, c'est expliqué ici (je l'ai lu en diagonale)

[Jack]

On diverge de la discussion originale, mais je ne suis pas trop d'accord sur les langages interprétés que tu as cités. Si les différences étaient simples à l'origine, ça s'est un peu compliqué depuis quelques temps: pour moi, visual basic (jusque VB6) génère un exécutable, c'est donc un langage compilé.
Avec les versions actuelles de VB, pour le framework .net, on se retrouve comme pour java dans une situation hybride: ces langages sont compilés pour obtenir du byte code qui n'est pas directement exécutable par le processeur, mais "interprétés" par la machine java ou .net.

A+