PIC: LCD com Menus

Como foi me pedido, neste post irei explicar como criar um menu, bem sofisticado, para um display de LCD.

Nesse menu, cada item pode conter um submenu, cada submenu pode conter outro submenu, e assim por diante, infinitamente( até acabar a memória ). Cada item pode também executar uma rotina ao ser selecionado.

Primeiramente cria-se um registro que irá armazenar as informações de cada item:

struct MenuItem
{
        const Item** mItem;     //SubMenu
        char Texto[16];         //texto
        void(*Tarefa)(char);    //Funcao a ser executada
        char Parms;             //valor do parametro da funcao
};

Depois criamos os items...

const  Item Menu01 = { Screen1, "FUNCAO 1", &SuaFuncao, 0 };
const  Item Menu02 = { Screen2, "FUNCAO 2", NULL, 0 };

Screen1 - é o vetor de itens do submenu. Se não possui um submenu colocar 0.

"FUNCAO 1" - É o texto do item a ser exibido.

&SuaFuncao - É o endereço da função a ser executada pelo item ao ser selecionado. Se não tiver, colocar 0.

0 - é o valor do parâmetro a ser passado para a função dita anteriormente.

e um vetor que armazena os itens da primeira tela a ser exibida.

//Terminar sempre com 0(Zero).
const Item* TelaInicial[] = { &Menu01, &Menu02, 0 }; 

Criamos tambem os itens de uma segunda, terceira, ... , tela:

const Item Menu10 = { Screen3, "Outra Funcao", 0, 0 };
const Item Menu11 = { NULL, "Ativar Saidas", &DefinirSaidas, 255 };
const Item Menu12 = { NULL, "Alternar Saidas", &AlternarSaidas, 0 };
const Item Menu13 = { NULL, "Desligar Saidas", &DefinirSaidas, 0 };
const Item* Screen1[] ={ &Menu10, &Menu11, &Menu12, &Menu13, 0 }; 

Esse código é mais fácil no sentido de poder acrescentar quantos itens e subitens quiser, sem ter que adicionar mais instruções "if", "else", "switch", etc, deixando o código mais limpo. Por outro lado, é necessário um conhecimento sobre o uso de estruturas( struct ) e ponteiros. Vocês podem ficar espantados ao ver tanto asterisco, como nesse trecho do código "static const Item*** MenuAnterior". Para quem quiser entender, irei explicar:
Com Apenas um asterisco: Item* - É um simples ponteiro para um struct Item.
Com dois asterisco: Item** - É um vetor de *Item.
Com três asterisco: Item*** - É um vetor de **Item. ( ou matriz de *Item ).

CÓDIGO:

/*
  PROJETO: LCD com MENUS
  MCU: PIC18F4550
  CLOCK: 48MHz ( 20MHz + PLL )
  COMPILADOR: MIKROC PRO PIC
  AUTOR: Tiago Henrique
*/

#define NULL 0

//PINOS DO LCD
sbit LCD_RS at RB0_bit;
sbit LCD_EN at RB1_bit;
sbit LCD_D4 at RB2_bit;
sbit LCD_D5 at RB3_bit;
sbit LCD_D6 at RB4_bit;
sbit LCD_D7 at RB5_bit;

sbit LCD_RS_Direction at TRISB0_bit;
sbit LCD_EN_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB4_bit;
sbit LCD_D7_Direction at TRISB5_bit;


/*
       PROTOTIPOS
*/
typedef struct MenuItem Item;
static void LcdWriteFromROM( const char* texto );
//Suas Funcoes
void DefinirSaidas( char );
void AlternarSaidas( char );



struct MenuItem
{
        const Item** mItem;     //submenu
        char Texto[16];         //texto
        void(*Tarefa)(char);    //Funcao a ser executada
        char Parms;             //valor do parametro da funcao
};

/*
       VARIAVEIS GLOBAIS
*/
static char selecao = 0;        //posicao do item selecionado
static const Item** MenuAtual;  //Menu Atual
static const Item*** MenuAnterior; //Pilha de Menus
static unsigned Stack[16];      //Aloca memoria para a pilha



/*
       MENU
*/

//Terceiro Nivel
const Item Menu30 = { NULL, "PORTD = 32", &DefinirSaidas, 32 };
const Item* Screen3[] = { &Menu30, 0 }; //Terminar sempre com o valor 0(NULO)

//Segundo Nivel
const  Item Menu10 = { Screen3, "Outra Funcao", 0, 0 };
const  Item Menu11 = { NULL, "Ativar Saidas", &DefinirSaidas, 255 };
const  Item Menu12 = { NULL, "Alternar Saidas", &AlternarSaidas, 0 };
const  Item Menu13 = { NULL, "Desligar Saidas", &DefinirSaidas, 0 };
const Item* Screen1[] = { &Menu10, &Menu11, &Menu12, &Menu13, 0 };  //Terminar sempre com o valor 0(NULO)

const  Item Menu20 = { NULL, "PORTD = 1", &DefinirSaidas, 1 };
const  Item Menu21 = { NULL, "PORTD = 2", &DefinirSaidas, 2 };
const  Item Menu22 = { NULL, "PORTD = 4", &DefinirSaidas, 4 };
const  Item Menu23 = { NULL, "PORTD = 8", &DefinirSaidas, 8 };
const Item* Screen2[] = { &Menu20, &Menu21, &Menu22, &Menu23, 0 }; //Terminar sempre com o valor 0(NULO)

//Primeiro Nivel
const  Item Menu01 = { Screen1, "FUNCAO 1", NULL, 0 };
const  Item Menu02 = { Screen2, "FUNCAO 2", NULL, 0 };
const Item* TelaInicial[] = { &Menu01, &Menu02, 0 }; //Terminar sempre com o valor 0(NULO)




/*
      Exibe os items do menu atual no display LCD
*/
static char MostrarItens( const Item* menu[], char sel )
{
char index = 0, row = 1;

     Lcd_Cmd( _LCD_CLEAR );

     if( menu == 0 )
         return 0;

     while( menu[index] )
     {
             if( index < sel ) { index++; continue; }
             if( index == sel ) Lcd_Chr( row, 1, '>' );
             else Lcd_Chr( row, 1, ' ' );
             row++;
             LcdWriteFromROM( menu[index++]->Texto );
     }

     if( index <= sel )
         return 1;
     return 0;
}

static void LcdWriteFromROM( const char* texto )
{
    while( *texto )
    {
           Lcd_Chr_CP( *texto++ );
    }
}



void main()
{
char flags = 0; //flags dos botoes

    CMCON = 7;
    ADCON1 = 15;
    //Botoes
    TRISA.B0 = 1;
    TRISA.B1 = 1;
    TRISA.B2 = 1;
    TRISD = 0;
    PORTD = 0;
    
    Lcd_Init();
    Lcd_Cmd( _LCD_CURSOR_OFF );

    MenuAtual = TelaInicial; //A tela atual = tela inicial
    MenuAnterior = &Stack;   //Aponta para a pilha
    
    MostrarItens( MenuAtual, selecao ); //Exibe os itens

    while( 1 )
    {
         if( PORTA.B0 ) flags.B0 = 1;
         else if( PORTA.B1 ) flags.B1 = 1;
         else if( PORTA.B2 ) flags.B2 = 1;

         //Botao Proximo foi pressionado
         if( !PORTA.B0 && flags.B0 )
         {
             ++selecao; //seleciona o proximo item
             //Exibe os itens da tela selecionada e
             //se o indice do item estourar
             //retorna para o primeiro item
             if( MostrarItens( MenuAtual, selecao ).B0 )
             {
                  selecao = 0;
                  MostrarItens( MenuAtual, selecao );
             }
             flags.B0 = 0;
         }
         
         //Botao Enter foi pressionado
         if( !PORTA.B1 && flags.B1 )
         {
             //Recebe o ponteiro da funcao a ser executada
             void(*Func)(char) = MenuAtual[selecao]->Tarefa;
             

             //Caso exista uma funcao a ser executada...
             if( Func != NULL )
             {
                 //Executa a função
                 Func( MenuAtual[selecao]->Parms );
             }

             //Se existir um submenu
             if( MenuAtual[selecao]->mItem != NULL )
             {
                 //Salva o menu atual no MenuAnteror
                 *MenuAnterior++ = MenuAtual;
                 //atualiza o menu atual com o proximo menu
                 MenuAtual = MenuAtual[selecao]->mItem;
                 //Exibe os itens deste proximo menu
                 selecao = 0;
                 MostrarItens( MenuAtual, selecao );
             }
             
             flags.B1 = 0;
         }
         
         //Botao Voltar foi pressionado
         if( !PORTA.B2 && flags.B2 )
         {
              selecao = 0;
              //Se não for o primeiro menu( Tela Inicial )
              if( ((unsigned*)&MenuAnterior)[0] > (unsigned)&Stack )
              {
                 //MenuAtual recebe o menu salvo no MenuAnterior
                 MenuAtual = *--MenuAnterior;
                 MostrarItens( MenuAtual, selecao );
              }
              flags.B2 = 0;
         }
    }

}

//Suas Funcoes

void DefinirSaidas( char valor )
{
    PORTD = valor;
}

void AlternarSaidas( char valor )
{
     PORTD = ~PORTD;
}

DOWNLOAD:
Projeto: LCD_com_menus.rar

O código pode ser um pouco difícil de entender, então, qualquer dúvida é só perguntar. Até mais!!!!