Gestions des menus avec pic

[invite2d9e7c03]

Bonjour,

Je désire créer un système de menus dans mon projet.
écran=afficheur alphanumérique 1*16
uC=PIC16F877A
Compilateur=mikroC
Structure de menus:
MENU 1="";
MENU 1.1="";
MENU 1.2="";
MENU 1.3="";

MENU 2="";
MENU 2.1="";
MENU 2.2="";
MENU 2.3="";
MENU 2.4="";
MENU 2.5="";

MENU 3="";
MENU 3.1="";
MENU 3.2="";
MENU 3.3="";

MENU 4="";
MENU 4.1="";
MENU 4.2="";
MENU 4.3="";
MENU 4.4="";

chaque menu(ou sous menu) se compose d'un maximum de 16 caractères.

J'ai fait plusieurs essais mais j'ai trouvé que mes méthodes(les classiques) sont gourmandes en ressources mémoires)

• 1er essai

char *menu1[] = {"menu1", "menu1.1", "menu1.2", "menu1.3"};// j'ai déclaré chaque menu sous forme d'un tableau en ram
char *menu2[] = {"menu2", "menu2.1", "menu2.2", "menu2.3"};// 
....

puis suites à des actions qui définissent i et j (menu i.j)

switch (i) {
case 1: ecran = menu1[j]; break;
case 2: ecran = menu2[j]; break;
case 3: ecran = menu3[j]; break;
case 4: ecran = menu4[j]; break;
}

puis j'affiche écran(chaine de caractère en ram)

le problème de cette méthode c'est que il reste pas d'espace continue en ram pour saisir toutes les chaines de menus

• 2eme essai

On m'a conseillé d'utiliser des constantes:
const char *menu1[] = {"menu1", "menu1.1", "menu1.2", "menu1.3"};

m'ai j'ai constaté que mikroC stocke ces variables en ram
et en plus j'ai des difficultés à les gérer (incompatibilités)

• 3eme possibilité

SEB.26 m'a proposé de travailler avec des listes chainés(c'est le première fois que j'entends parler de cette méthode) j'ai consulté Wikipédia pour comprendre un peu, j'ai pas réussi à le faire(ça parle de la théorie). Ça serai gentil si quelqu'un pourrait m'expliquer le truc avec un exemple appliqué à mes menu.

• 4eme possibilité

si quelqu'un a déjà réaliser un programme semblable. ça sera très bien de voir les idées des autres.(ou bien des liens sur la toile)

Je vous remercie d'avance.
-----

[Jack]

ecran = menu1[j]

l'utilisation de = avec des chaines ne peut pas fonctionner. Il faut utiliser strcpy.

On m'a conseillé d'utiliser des constantes:

const char *menu1[] = {"menu1", "menu1.1", "menu1.2", "menu1.3"};



m'ai j'ai constaté que mikroC stocke ces variables en ram

As tu bien lu la doc de ton compilateur? Il doit bien y avoir moyen de paramétrer son comportement:
options, directives diverses dans le source (pragma), etc.
En principe, les données et le programme sont affectés à des segments, ces segments se situant en ROM ou en RAM à des adresses définies à la compilation. Tu dois pouvoir forcer des variables à être stockées dans tel ou tel segment.

A+

[invite2d9e7c03]

merci jack pour la réponse

l'utilisation de = avec des chaines ne peut pas fonctionner. Il faut utiliser strcpy.

avec mikroC j'ai essayé et ca marche

As tu bien lu la doc de ton compilateur? Il doit bien y avoir moyen de paramétrer son comportement:
options, directives diverses dans le source (pragma), etc.
En principe, les données et le programme sont affectés à des segments, ces segments se situant en ROM ou en RAM à des adresses définies à la compilation. Tu dois pouvoir forcer des variables à être stockées dans tel ou tel segment.

A+

tu as raison j'ai trouvé dans le doc de compilateur: Flash_Read et flash_write
ç doit marcher je vais essayer

[katmai]

ça a l'air de marcher mais enfaite non.

Je suis sur que si tu modifies une des deux chaines les deux chaines sont modifiées. En réalité si tu fais ecran = menu[j] alors tu copies l'adresse du premier caractère et tu pointes sur la même chaine de caractère et là il y a plein de problème qui peuvent apparaître.

Fais une petite recherche sur les chaînes de caractère et sur les pointeurs le principe n'est pas bien compliqué à comprendre.

Pour strcpy voir ici.

A+

[A voir en vidéo sur Futura]

[Seb.26]

Un début de réponse sur les listes chainées :
http://carl.seleborg.free.fr/cpp/cou...nked_list.html

NB: Ce dont tu as besoin, c'est d'un arbre représentée sous forme chainée ...

Une liste chainée, n'est rien de plus qu'une structure dans laquelle tu as des données et un/des pointeurs vers d'autres éléments du même type ...

Par exemple dans ton cas, je ferais :

struct t_MenuItem
{
  rom char *text;
  //
  t_MenuItem *rootItem;
  //
  t_MenuItem *previousItem;
  t_MenuItem *nextItem;
  //
  t_MenuItem *subItem;
};

Ce qui te permet de représenter n'importe quel menu comme un arbre 2D.

[Avancé...]
Si peux te passer de rooItem si tu ajoute à chaque sous menu un item "go up menu" dont le subItem est en fait le rootItem du premier item du sous menu actuel ...
( oui, je sais ... pas évident non plus à écrire !!! )

Tu peux aussi virrer le previousItem, mais alors tu ne peux plus que aller à l'item suivant, et il te faut donc aussi mettre le premier item du sous menu actuel en tant que nextItem de l'item "go up menu" ... mais alors l'utilisateur qui rate son item, doit faire un tour complet ... à toi de voir ...

Voilà, avec tout cela, tu peux te faire une gestion de menu, navigation avec 2 boutons ( NEXT + OK ), jusqu'a 4 boutons ( NEXT + PREVIOUS + RETURN + OK )

[Seb.26]

PS: pour tes chaines de caractères, place les en flash : chercher "rom" dans la doc de ton compilo ...

Et fais toi une fonction d'affichage qui prend un "rom char*" en entrée ...

Voilà de bien bons exercices (de base en algo) !!!
... manipulation de chaines de caractères, arbre chainé ...

[Seb.26]

PS: si tu ne compte pas modifier ton menu dynamiquement, place tout en rom :

struct _t_MenuItem
{
  rom char *text;
  //
  rom t_MenuItem *rootItem;
  //
  rom t_MenuItem *previousItem;
  rom t_MenuItem *nextItem;
  //
  rom t_MenuItem *subItem;
};
#define t_MenuItem struct _t_MenuItem

[Seb.26]

l'utilisation de = avec des chaines ne peut pas fonctionner. Il faut utiliser strcpy.

... ce sont des char*, donc c'est tout à fait correct AMA.

[invite2d9e7c03]

... ce sont des char*, donc c'est tout à fait correct AMA.

Oui et la preuve que je l'ai simulé avec un afficheur.

[invitee9dcae4d]

Comme le dit katmai, ce qui parait dangereux en faisant comme ça c'est qu'on donne à "ecran" l'adresse de "menux[j]".
Donc si on modifie le contenu à l'adresse d'ecran, on tente de modifier le menu (qui est dans ce cas une constante non modifiable, donc ça risque d'être dérangeant).

Ca peut fonctionner, mais ce n'est peut-être pas la meilleure façon de procéder.

Ps: j'ai essayé de mettre des "const" dans mikroC et tout est bien copié en ROM. T'es sûr de ton coup ?

[Seb.26]

Comme le dit katmai, ce qui parait dangereux en faisant comme ça c'est qu'on donne à "ecran" l'adresse de "menux[j]".
Donc si on modifie le contenu à l'adresse d'ecran, on tente de modifier le menu (qui est dans ce cas une constante non modifiable, donc ça risque d'être dérangeant).

Heu oui ... c'est un peu le principe des pointeurs ...

Maintenant si tu trouve ça dangereux et que tu n'en veuille pas, il faut probablement changer de langage.
Le Java, le C# ou encore l'ADA peuvent mieux correspondre à ce que tu cherche ... ?

Mais tu devras alors aussi changer de uCPU ...

[invite2d9e7c03]

Ps: j'ai essayé de mettre des "const" dans mikroC et tout est bien copié en ROM. T'es sûr de ton coup ?

Oui tu as raison j'ai reverifié ce point.
mais je rencontre plein de problème avec ces chaines en rom
j'arrive pas même à afficher une chaines(déclaré en const)
le compilateur répond illegal pointer conversion e internal error
puisqu'on utilise le meme compilateur essaie de manipuler une const.
si quleuq'un réussit à le faire et m'explique .. le problème est résolu.

[invite2d9e7c03]

par exemple

const char menu[] = "XXXXXX" ;

void main() {
  Lcd_Config(&PORTD, 7, 5, 6, 3, 2, 1, 0);
  Lcd_Cmd(LCD_CLEAR);
  Lcd_Cmd(LCD_CURSOR_OFF);
  Lcd_Out(1, 1, menu);
}

à ce code le compilateur répond: illegal pointer conversion [?T1] to [text]
le message diaprait en supprimant "const" .
@+

[Seb.26]

A croire que tu ne lis pas les posts ... lol

Je parie que le prototype de ta fonction Lcd_Out est :
Lcd_Out( int , int, char* );

Il te faut des fonctions qui accepte les pointeur en rom !!!

Donc soit elles existent, soit tu fais un fonction passerrelle qui recopie la chaine en RAM avant de faire ton Lcd_Out() ...

NB: déclarer une variable en const suffit à la placer en ROM avec MikroC ???
pourquoi pas après tout ...

[Seb.26]

Et avant que tu ne demande ...

File moi le proto de ta fonction Lcd_Out() et je te pond le code de Lcd_Out_rom() ...

[Seb.26]

Voilà ...

#define MAX_STRING_SIZE 32
void Lcd_Const_Out( unsigned char row, unsigned char col, const char *pString )
{
  char temp[MAX_STRING_SIZE];
  char *pTemp = temp;

  while(*pTemp++=*pString++);

  Lcd_Out( row, col, temp );
}

[invitee9dcae4d]

Heu oui ... c'est un peu le principe des pointeurs ...

Maintenant si tu trouve ça dangereux et que tu n'en veuille pas, il faut probablement changer de langage.
Le Java, le C# ou encore l'ADA peuvent mieux correspondre à ce que tu cherche ... ?

Mais tu devras alors aussi changer de uCPU ...

Je sais bien que c'est le principe des pointeurs, mais dans ce cas-ci avec des "const", n'est-ce pas plus délicat ?
(ou alors on part du principe qu'avec un pointeur sur chaîne on ne tente pas de modifier la chaîne et donc pas de problème ?)

Pour LCD_Out, le prototype est effectivement (t'y étais presque ! ) :
void LCD_Out(char, char, char*);

Chez moi, j'ai créé une fonction "copy":

void copy(char* dest, const char* source)
{
while(*dest++=*source++);
}

J'ai une variable locale char ecran[16];
Et je fais :

copy(ecran, menu1[0]);
LCD_Out(1,1, ecran);

Edit:

Bah t'as été plus vite mais l'idée est la même : ).

[Seb.26]

dans ce cas-ci avec des "const", n'est-ce pas plus délicat ?
(ou alors on part du principe qu'avec un pointeur sur chaîne on ne tente pas de modifier la chaîne et donc pas de problème ?)

Bah, dans le cas contraire ça veut dire que ton code fait ce qu'il veut ???

Et puis, le compilo ne te laissera pas faire du code illégal normalement ...

Un char* n'est pas un const char* ... le compilo le sait ...

const char toto = 10;
const char[] str = "Hello world";
...
toto = 20; // -> Error
str[10] = '\0'; // -> Error
...
char *str2 = str; // -> Error

Donc où est le problème ?

[invitee9dcae4d]

Je pensais plus à quelque chose du genre :

const char *str = "abc";
char* test;

test = str;
*test = "dd";

C'est inutile, ça passe à la compilation (sous Visual Studio), mais évidemment, ça plante. ; )

Ps: mes connaissances des chaînes de caractères sont limitées, je l'admets volontiers.

[Seb.26]

C'est inutile, ça passe à la compilation (sous Visual Studio), mais évidemment, ça plante. ; )

Bah non, ça compile pas ...

Erreur 1 error C2440: '='*: impossible de convertir de 'const char *' en 'char *' ***\Test.cpp	36

[Seb.26]

const char *str = "abc";
char* test;

test = str;
*test = "dd";

C'est ultra incorrect ça ... tu tente de mettre un "const char *" dans un "char" ...

[invitee9dcae4d]

Tu veux dire que je devrais faire *test = 'd' ?
Si c'est bien ça, je m'en suis rendu compte, mais trop tard pour éditer ; ).
(j'avais juste un Warning à ce sujet, étonnant)

Et pour l'autre j'ai (Visual Studio 2008) :

Avertissement	1	warning C4090: '='*: qualificateurs 'const' différents	***\main.c	218	ProgramC

Donc ça compile correctement. Enfin, j'aurai de toute façon découvert aujourd'hui qu'on ne pouvait modifier une chaîne : ).

[Jack]

... ce sont des char*, donc c'est tout à fait correct AMA.

Il aurait fallu que je connaisse le type de ecran .

C'est sur qu'on peut toujours faire des affectations de pointeurs.

A+

[invite2d9e7c03]

Voilà ...

#define MAX_STRING_SIZE 32
void Lcd_Const_Out( unsigned char row, unsigned char col, const char *pString )
{
  char temp[MAX_STRING_SIZE];
  char *pTemp = temp;

  while(*pTemp++=*pString++);

  Lcd_Out( row, col, temp );
}

Merci c'est exactement ce que je cherche.
je dois essayer de reconstituer mon programme avec cette fonction.

@+

[Seb.26]

Tu veux dire que je devrais faire *test = 'd' ?
Si c'est bien ça, je m'en suis rendu compte, mais trop tard pour éditer ; ).

Oui, c'est ça
NB: ce forum est bien @}£µ%@ pour ça !!! 5 minutes ... trop court !

Et pour l'autre j'ai (Visual Studio 2008) :

Avertissement	1	warning C4090: '='*: qualificateurs 'const' différents	***\main.c	218	ProgramC

Ah tient donc, c'est étrange ça !

Je suis sous VS2005 et il me balance une erreur ( ce qui me semble normal )

Et ensuite, tu as le droit de tenter de modifier le const ? le compilo braille pas ??? ... mais tu prends une erreur d'écriture, c'est ça ?

Au temps pour moi alors ...

[invitee9dcae4d]

C'est tout à fait ça, aucune erreur à la compilation (à part le Warning) et puis violation d'écriture une fois lancé ; ).

Enfin, ce sujet m'aura permis de réfléchir un peu mieux au "fonctionnement" des chaînes de caractères, ça ne fait pas de mal. Merci pour les réponses : ).

Impatient de voir la suite maintenant !

[Seb.26]

Impatient de voir la suite maintenant !

Oui, amgab2003 a du pain sur la planche !!!

[invite2d9e7c03]

Slaut,
Comment passer des const en ram (j'ai besoin de faire des affectation et d'appeler la fonction strlen() )
Comment faire?
j'ai pas pus comprendre le fonctionnement de Lcd_Const_Out sinon je pourrai me débrouiller.
merci d'avance

[invitee9dcae4d]

void Lcd_Const_Out(unsigned char row, unsigned char col, const char *pString)
{
char temp[MAX_STRING_SIZE]; -> On crée un tableau local temporaire
char *pTemp = temp; -> On crée un pointeur vers ce tableau (on ne peut pas faire de temp++ car temp représente l'adresse du premier élément et donc non modifiable)

while(*pTemp++=*pString++); -> On assigne les valeurs de chaque lettre une par une à pTemp.
Tant qu'un caractère est trouvé, la boucle continue et "ne fait rien" ( ; ).
Une fois qu'on rencontre \0 qui est le caractère final d'une chaine de pString, on s'arrête.
Le parcours de la boucle a permis de recopier la chaîne dans temp[].

Lcd_Out( row, col, temp );
}

On peut donc faire le même genre de manipulation pour strlen :

char strlen_const(const char *pString)
{
   char cCount = 0;
   while(*pString++)
        cCount++;
        
   return cCount;
}

[invitee9dcae4d]

Comme conseillé sur abcelectronique, tu peux aussi faire ton LCD_Const_Out comme ceci :

void Lcd_Const_Out(unsigned char row, unsigned char col, const char *pString)
{
  Lcd_Out(row, col, "");
  while(*pString)
    Lcd_Chr_Cp(*pString++);
}

Ce qui a l'avantage de ne pas nécessiter de variable temporaire et donc gain en RAM.
(Lcd_Chr_Cp() écrit le caractère à la position "du pointeur du LCD")
(avec éventuellement un LCD_Cmd(LCD_CLEAR); si besoin)