[C]-Mise en forme d'un environnement sur LCD graphique

[jorg1n]

Bonjour,
je pense que la question n'est pas très clair, alors je m'explique...
je suis entrain de réaliser un programme en C qui permet d'acquérir (avec mon pic) des tensions provenant de différents module, et j'affiche ensuite le résultat sur mon afficheur graphique...vous comprendrez mieux avec le schéma en pièce jointe...
Ce que je souhaite c'est pouvoir "naviguer" entre les menus par le biais de 3 BP(donc par interruptions), voir le principe en pièce jointe, ce sera plus compréhensif...

Je pensai faire un "truc" du style:

if (INT0IF==1)
    {
    if(view==0)
        {
         goto V1
        }
    }
if(INT1F==1)
    {
    if(view==0)
        {
         goto V2
        }
    }
if(INT2F==1)
    {
    if(view==0)
        {
         goto V3
        }
    }

Il s'agit du principe...mais, cela peut il etre correct avec des "goto"?
Ou avez vous une autre solution.
Je vous remercie d'avance
-----

[Seb.26]

Mais pourquoi donc c'est une manie ici d'utiliser les IT dès qu'il y a des BP ???

Pourquoi tu estime avoir besoin d'associer une IT à tes BP ???

Sinon, d'un point de vu dev, ce que tu cherche s'appelle AMA "automate d'états"
http://fr.wikipedia.org/wiki/Automate_fini

[jorg1n]

Bonjour,

je pensais que les interruptions était un choix correct car je dois réaliser des conversions analogiques numériques et afficher le résultat, et dès qu'il y a une interruption, je change la valeur de la variable et je me redirige vers un autre affichage.
Mais après réflexion, je peut aussi faire ça sous forme de boucle:

do
{
conversion AN
Affichage
}
while ( BP1==1 || BP2==1 || BP3==1);
 
if(BP1==1)
{
....
...
}

Mais avec le nombre de fenetre d'affichage (3 module de mesures et 3 fenetre différente pour chaque module) que j'ai, ça fait un bel arbre généalogique non?
Comment me conseillez vous de faire?
Merci encore

[Seb.26]

Tu as regardé ce que je t'avais posté ? ... ça te va pas ? ( pourquoi ? )

Sinon, d'un point de vu dev, ce que tu cherche s'appelle AMA "automate d'états"
http://fr.wikipedia.org/wiki/Automate_fini

[A voir en vidéo sur Futura]

[jorg1n]

Sincèrement, je n'ai pas trop bien compris le principe...
ca que je souhaite faire correspond "un peu" au premier dessin", mais j'aurais plusieurs états... et au point de vue programmation? il vaut mieux utiliser quel principe?
Merci encore

[Seb.26]

Sincèrement, je n'ai pas trop bien compris le principe...

Ok ...

En fait en gros, le principe c'est d'avoir ce que l'on pourrait appeler une tache applicative.

Au boot de ton projet, la tache va dans un état "Init" en général, ensuite une fois l'init OK, elle passe en "IDLE" ... là, elle attends des évènements qui vont déclencher des transissions d'état ...

ça a l'air galère comme ça, mais en fait c'est ultra simple

(pseudo-code)

// boucle principale
while(1)
{
  ...
  tache_appli();
  ...
}

(tache_appli.c)

typedef enum{
  INIT,
  IDLE,
  MENU_1,
  MENU_2
} e_tache_appli_State;

e_tache_appli_State myState = INIT;

void tache_appli( void )
{
  switch( myState )
  {
  case INIT:
    // faire l'init de ta tache
    ...
    // passer à l"état suivant
    myState = IDLE;
    break;

  case IDLE:
    // attendre un évènement ( BP1 ou BP2 ici )
    if (BP1)
      myState = MENU_1;
    //
    if(BP2)
      myState = MENU_2;
    break;

  case MENU_1:
    // afficher le menu, puis attendre le prochain évènement
    printf( "Menu_1" );
    //
    if(BP1)
      myState = IDLE;
    //
    if(BP2)
      myState = MENU_2;
    break;

  case MENU_2:
    // afficher le menu, puis attendre le prochain évènement
    printf( "Menu_2" );
    //
    if(BP1)
          myState = IDLE;
    break;
  }
}

Dans cet exemple, au boot, tu passe par l'init, ensuite tu vas en IDLE, de là si tu fait BP1, tu vas en Menu_1, et en Menu_2 si tu fais BP2 ... du Menu_1 tu peux retourner au début (IDLE) via BP1, ou aller en Menu_2 via BP2 ... et du Menu_2, tu ne pux que retourner en IDLE via BP1 ...

[Seb.26]

Nb: Ensuite, tu vas étoffer le principe selon tes besoins ( genre prévoir de n'exécuter du code que lors de l'arrivée ou de la sortie d'un état ... )

[jorg1n]

Je vais travailler tout ça ...
je te remercie beaucoup

[Seb.26]

de nada ...

( encore toi ?!! )

[jorg1n]

Et oui c'est encore....
bon je me retrouve devant un petit problème, lorsque je suis sur mon "IDLE", voila ce que je fais:

     case IDLE:
        monitor_123 ();
        do{
          RA2=1;          //Me permet de me situer dans le programme
          DELAY_MS(250);
          RA2=0;
          DELAY_MS(250);
          }
        while((RB0==1)||(RB1==1)||(RB2==1));
        if(RB0==0)
          {
          myState = Mod_1;
          }
        if(RB1==0)
          {
          myState = Mod_2;
          }
        if(RB2==0)
          {
          myState = Mod_3;
          }
      break;

et il reste toujours dans la boucle do()while... ma synthaxe est t'elle bonne?

        while((RB0==1)||(RB1==1)||(RB2==1));

car j'ai juste essayé avec while(RB0==1), et ça fonctionne...

Merci d'avance

[Seb.26]

En principe, on ne reste pas bloqué dans la procédure de la tache appli, c'est justement l'interet ... car en parrallèle tu peux faire autre chose ...

Utiliser les Delay(ms() n'est pas une bonne solution dans 80% des cas ... dans le tiens par exemple, une boucle cadencée par un timer serait bien plus propre et moins limitatif pour la suite ...
( j'avais déjà fait quelques posts là dessus, une petite recherche devrait t'y emmener )

En fait, le concept là dessous, c'est que tu viens de te faire une tache applicative, que tu vas exécuter régulièrement ( par exemple toute les 5ms ) ... mais l'interet du truc, c'est que tu peux aussi faire une tache LCD qui te servira de drivers, une autre pour filtrer les signaux de capteurs, une autre qui dialoguera avec u PC via l'UART ... et tout communique et tourne en parallèle ...

Mais si toi tu me pose un while(); dans la fonction, et bien tout le reste s'arrête aussi ...

[Seb.26]

     case IDLE:
        monitor_123 ();
/*
BEURK !!!
        do{
          RA2=1;          //Me permet de me situer dans le programme
          DELAY_MS(250);
          RA2=0;
          DELAY_MS(250);
          }
*/
/*
Pourquoi faire ça ???
        while((RB0==1)||(RB1==1)||(RB2==1));
*/
        if(RB0==0)
          {
          myState = Mod_1;
          }
        if(RB1==0)
          {
          myState = Mod_2;
          }
        if(RB2==0)
          {
          myState = Mod_3;
          }
      break;

[jorg1n]

Bonjour,

en fait ce que je voulais faire, c'est ça:

case IDLE:
        monitor_123 ();  //affichage de l'ensemble (graduation,...)(view0)

        do{
         conversionAN();   //conversion AN sur AN0
         affichresult();      //affichage du résultat sur view0
          }
        while((RB0==1)||(RB1==1)||(RB2==1));   //tant que aucun bouton n'est appuyé
*/
        if(RB0==0)
          {
          myState = Mod_1;   // pour affichage de view1
          }
        if(RB1==0)
          {
          myState = Mod_2;   // pour affichage de view2
          }
        if(RB2==0)
          {
          myState = Mod_3;   // pour affichage de view3
          }
      break;

Voila la raison pour laquelle je veux faire un do {}while().
Au final, je voudrai un "case" pour chaque view sur mon afficheur..
Penses tu que ça pourrai marcher?
merci encore

[Seb.26]

Voila la raison pour laquelle je veux faire un do {}while().
Au final, je voudrai un "case" pour chaque view sur mon afficheur..
Penses tu que ça pourrai marcher?
merci encore

> Oui, je comprends bien, mais c'est une mauvaise raison ( ou alors il ne te faut pas utiliser le concept que je te propose )
> ça pourrait marcher, mais tu perds tout l'intérêt du truc puisque tu bloque ton automate
> de rien

Maintenant ... pourquoi faire :

case IDLE:
        monitor_123 ();  //affichage de l'ensemble (graduation,...)(view0)

        do{
         conversionAN();   //conversion AN sur AN0
         affichresult();      //affichage du résultat sur view0
        }
        while((RB0==1)||(RB1==1)||(RB2==1));

        if(RB0==0)
          {
          myState = Mod_1;   // pour affichage de view1
          }
        if(RB1==0)
          {
          myState = Mod_2;   // pour affichage de view2
          }
        if(RB2==0)
          {
          myState = Mod_3;   // pour affichage de view3
          }
      break;

NB: d'ailleur, pour moi y'a un bug dans le test de ton while ... puisque pour en sortir, il faut presser les 3 BP ...

Alors que :

case IDLE:
        monitor_123 ();  //affichage de l'ensemble (graduation,...)(view0)

        conversionAN();   //conversion AN sur AN0
        affichresult();      //affichage du résultat sur view0

        if(RB0==0)
          {
          myState = Mod_1;   // pour affichage de view1
          }
        if(RB1==0)
          {
          myState = Mod_2;   // pour affichage de view2
          }
        if(RB2==0)
          {
          myState = Mod_3;   // pour affichage de view3
          }
      break;

Fait la même chose ... mais ne bloque pas ton programme inutilement ...

[jorg1n]

NB: d'ailleur, pour moi y'a un bug dans le test de ton while ... puisque pour en sortir, il faut presser les 3 BP ...

Voila pourquoi, ça ne fonctionnait pas...
avec ça:

while((RB0==1) && (RB1==1) && (RB2==1));

ça marche mieux...
en ce qui concerne le blocage du programme, justement, je souhaite que le programme reste dans la boucle et fasse continuellement la lecture de la tension et son affichage, sans réafficher tout le "décor" de view0.
Me déconseilles tu de faire cela?
merci pour tes conseils...

[Seb.26]

en ce qui concerne le blocage du programme, justement, je souhaite que le programme reste dans la boucle et fasse continuellement la lecture de la tension et son affichage, sans réafficher tout le "décor" de view0.
Me déconseilles tu de faire cela?

OUI !

[Edit] PS: tu parle de view() que tu ne veux pas faire à chaque fois ... OK, il te suffit de creer des évènements d'entrée dans un état et de sortie d'un état ... comme ça, tu n'exécute des portions de code que quand tu entre et sort d'un état de ton automate ...

Car OK, pour le moment tu veux que ton programme reste à mesurer et à afficher ( ce que tu peux faire sans pour autant tout bloquer ) ... Mais comment fera tu si demain tu veux aussi faire autre chose ? ... et bien soit tu pourras pas, soit ton code va devenir un plat de spaghettis ...

Si tu regarde mon bout de code au dessus, tu verras que ma version ne fait aussi que mesurer et afficher sans fin, tant que tu n'actionne pas de BP ... exactement comme ta boucle while() ...

Je suis d'accord que c'est pas évident de "penser" de cette façon au début, mais c'est l'apprentissage de "bonnes façons" ( il n'y a pas que celle ci, il y a d'autres "bonnes façons"de faire les choses ) de faire qui feront que tu seras bloquer plus tard ou pas quand tu auras fini l'étape "je bidouille quelques lignes de C, ça marche et c'est rigolo" ...

[jorg1n]

Bonjour,

après avoir réussi à réaliser "l'environnement de mon projet" sur mon afficheur graphique, je souhaite réaliser un menu déroulant ..mais je bloque un peut...
je voudrais faire un peu quelquechose dans ce style là: (voir pièce jointe)
Si quelqu'un a déja eu l'occasion de réaliser cela..je voudrais bien un peu d'infos..
merci d'avance

[Seb.26]

Bah ça doit pas être bien compliqué quand même, si ?

Le tout étant de savoir le niveau que tu souhaite ... dans ton exemple, je vois des options ... Tu veux aussi pouvoir gérer une arborescence de menu ou simplement du linéaire ? ...

Je pense qu'une structure en liste chainée devrait être OK et ne pas trop gaspiller de RAM ( AMA, utilise un index sur 1 octet, si tu depasse les 256 éléments, tu verras plus tard, mais ça commence à faire un beau menu 256 éléments ... )

Donc, tu as une structure de stockage ( liste chainée ), maintenant il te faut déterminer la structure des infos que tu vas stocker ( hors éléments liés à ta liste chainée )
Perso, je verrais bien un genre d'objet style C++, avec un header fixe ( au hasard : type et size ) qui grâce à un union permettrait une utilisation pseudo object.

Le noyau de ton gestionnaire de menu doit AMA permettre l'utilisation que quelques cellules de base :
> GOTO ( saut dans la liste chainée pour gérer les sous menus et retours )
> EXIT ( fermer le gestionnaire de menu )
> ITEM_ON_OFF ( un élément simple : du texte et une valeur 0/1 )
> ITEM_BYTE_DEC/ITEM_BYTE_HEX ( un élément simple : du texte et une valeur 00 à FF ou 0 à 255 ... éventuellement, rajoute un MAX_VALUE )
> ITEM_TEXT ( Juste du texte, avec si tu veux, de la mise en forme )

Ensuite, tu lance ton noyau MENU avec un point de départ, et il fait tout tout seul, jusqu'à tomber sur un EXIT. Tu n'as alors plus qu'a reprendre les valeurs de tes variables de la structure ...

Par contre, cela veut dire que ta structure est en RAM, ce qui est bof-bof ... pour pallier à ça, plutôt que de mettre directement les données dans la structure de chaque ITEM, tu peut utiliser un tableau de Bytes en RAM avec une indirection dans ce tableau ... ça augmente les risque d'erreurs à la saisie de ton menu, mais c'est plus économique en RAM ...

[Edit] Pour te simplifier la vie, fais toi une liste chainée qui marche dans les 2 sens ...

[jorg1n]

Merci Seb26...(que ferais-je sans toi!!! )

Le tout étant de savoir le niveau que tu souhaite ... dans ton exemple, je vois des options ... Tu veux aussi pouvoir gérer une arborescence de menu ou simplement du linéaire ? ...

Ce que je souhaite faire, c'est une fois que j'ai sélectionné à l'aide de la "petite flèche" et que j'appuie sur OK, c'est que je puisse modifier le paramètre à l'aide des flèches gauche /droite , et lorsque je réappui sur OK, je sauvegarde le paramètre (qui sera utilisé par la suite pour calcul si c'est une valeur).
Et descendre au paramètre suivant a l'aide des flèches gauche /droite...j'espère que je suis clair dans mes explications..

Merci pour tes explications, je vais travailler avec ça déja...

PS:Tu travailles dans quel domaine si c'est pas indiscret, tu fais de la programmation je suppose??

[Seb.26]

PS:Tu travailles dans quel domaine si c'est pas indiscret, tu fais de la programmation je suppose??

Oui, je dev des OS et des applis pour des systèmes embarqués ... Mais je fais aussi pas mal de dev sur PC ...

Ce que je souhaite faire, c'est une fois que j'ai sélectionné à l'aide de la "petite flèche" et que j'appuie sur OK, c'est que je puisse modifier le paramètre à l'aide des flèches gauche /droite , et lorsque je réappui sur OK, je sauvegarde le paramètre (qui sera utilisé par la suite pour calcul si c'est une valeur).
Et descendre au paramètre suivant a l'aide des flèches gauche /droite...j'espère que je suis clair dans mes explications..

Ok, donc pour le moment, tu pourrais te contenter d'un menu linéaire ... donc oublie les listes chainées, et fait directement un tableau de n item ... chaque item de ton menu sera représenté par une entrée du tableau ...

Comme je devine que c'est pas super clair, voilà un peu à quoi je pense :

enum MenuItem_Types {
	EXIT,
	ITEM_TEXT,
	ITEM_ON_OFF,
	ITEM_BYTE_DEC,
	ITEM_BYTE_DEC_MAX
};

struct t_MenuItem {
	unsigned char Type;
	char *Text;
	void *Data;
};

// "Menu_00_Item" = simple texte
const rom char Menu_00_Text[]				= "MON MENU";
//
const rom struct t_MenuItem Menu_00_Item		=	{ ITEM_TEXT, Menu_00_Text, NULL };

// "Menu_01_Item" = selection ON/OFF ( retour dans Menu_01_Data )
const rom char Menu_01_Text[]			= "Alarme : ";
unsigned char Menu_01_Data = 0;
//
const rom struct t_MenuItem Menu_01_Item		=	{ ITEM_ON_OFF, Menu_01_Text, &Menu_01_Data };

// "Menu_02_Item" = réglage, valeur max = 100 = 0x64 ( retour dans Menu_02_Data & 0x00FF )
const rom char Menu_02_Text[]			= "Réglage PWM : ";
unsigned short Menu_02_Data = 0x6400;
//
const rom struct t_MenuItem Menu_02_Item		=	{ ITEM_BYTE_DEC_MAX, Menu_02_Text, &Menu_02_Data };

#define myMenu_Size 3
const rom struct t_MenuItem *myMenu[myMenu_Size] = { &Menu_00_Item, &Menu_01_Item, &Menu_02_Item };

Ensuite, ton gestionnaire de menu prend la main, et affiche correctement chaque item ...

[jorg1n]

Merci Seb26...
Je vois que ça à l'air de se compliquer un peu!!!
Je vais voir comment je peut essayer d'adapter ça...
Merci encore..

[Seb.26]

Bah en fait, ça c'est ce que je considère comme une "belle" solution ... de cette façon, une fois que tu auras codé ça, tu pourras faire tout ce que tu veux comme menus ...

Maintenant, tu peux aussi faire plus simple ... Mais tu devras alors refaire à chaque fois 80% du boulot ...

PS: y'a rien de compliqué, c'est un tableau qui contient plusieurs structures qui elle même décrivent une ligne de ton menu ... ça peut faire un peu peur, mais en fait c'est plus simple qu'il n'y parait ...