Multiplexar display de 7 segmentos em C

[valecovo]

Olá
Estou aqui mais uma vez para pedir a vossa ajuda.

Estou a tentar fazer um voltímetro com PIC, mas não sei como separar os números para os apresentar num display de 7 segmentos. Com um disply LCD já consegui fazer.

Estou a usar linguagem C e o compilador PCW - CCS 4.114.

Se alguém me puder ajudar, agradeço desde já.

[andre_luis]

É preciso apresentar alguma informação do seu circuito e do que já tem no programa.


+++

[ze2]

isso é relativamente fácil. use uma tabela para decodificar para 7 segmentos. Uma varredura dentro de uma interrupt, usando a variável i como index para s[i], outra para deslocar num port os catotos (ou anodos) comuns e... bom mas isso tu não perguntaste ...vê abaixo se tem a ver com tua inquietação...

Código: Selecionar todos

#define un s[0] //pra facilitar entendimento
#define dez s[1]
#define cen s[2]
#define mil s[3]
#define dmil s[4]

unsigned char s[5]; //global
void decompor(unsigned int dado) //talvez word dê certo. nunca precisei
{
unsigned char i=0;
un=dez=cen=mil=dmil=0;
while(dado)
   {
   s[i]=dado%10;
   dado/=10;
   i++;
   }   
}

[tcpipchip]

Código: Selecionar todos

unsigned short conta, D1, D2, D3, D4;    //Variáveis de controle e de armazenamento
unsigned int ad,adc;                          //Variáveis de armazenamento da conversão AD

/*Matriz de 10 posições contendo o valor a ser enviado para a porta D a fim de
  mostrar o dígito referente nos displays */
int digito[10] =
               {0b00111111,    //Dígito 0
                0b00000110,    //Dígito 1
                0b01011011,    //Dígito 2
                0b01001111,    //Dígito 3
                0b01100110,    //Dígito 4
                0b01101101,    //Dígito 5
                0b01111101,    //Dígito 6
                0b00000111,    //Dígito 7
                0b01111111,    //Dígito 8
                0b01101111     //Dígito 9
               };


void interrupt()
{
  conta++;                        //Incrementa variável v
  if (conta > 4) conta = 1;        //Se variável v for maior que 4, então atribui o valor 1 a ela

  switch (conta) {
    case 1: PORTD = D1;     //Coloca na PORTD o valor referente ao dígito 1
            PORTA = 0x00;     //Aciona o primeiro display e desliga os demais
            PORTE = 0X01;
                break;
    case 2: PORTD = D2;     //Coloca na PORTD o valor referente ao dígito 2
            PORTE = 0x02;     //Aciona o segundo display e desliga os demais
                break;
    case 3: PORTD = D3;     //Coloca na PORTD o valor referente ao dígito 3
            PORTE = 0x04;     //Aciona o terceiro display e desliga os demais
                break;
    case 4: PORTD = D4;     //Coloca na PORTD o valor referente ao dígito 4
            PORTE = 0X00;
            PORTA = 0x20;     //Aciona o quarto display e desliga os demais
                break;
    }
  TMR0L = 100;                //  Atribui o valor 100 ao  TMRO
  INTCON.TMR0IF = 0;
}

void main()
{
  conta = 0;                    //Zera a variável v

  ADCON1 = 0X0E;         //Habilita somente o canal analógico 0

  PORTA          =   0x00;          //Limpa a porta A
  TRISA          =   0x01;          //Aciona a porta A como saída
  PORTD         =   0x00;          //Limpa a porta D (todos os LEDS apagados)
  TRISD          =   0x00;          //Aciona a porta D como saída
  TRISE         =   0x00;
  T0CON = 0b11000100;      /*Configura o Registrador T0CON
                                       TMR0ON = 1 -> Habilita o TIMER 0
                                       T08BIT = 1 -> TIMER 0 no modo 8 bits
                                       T0CS = 0 -> Incremento pelo ciclo de máquina
                                        ...0,5us para o cristal de 8MHz.
                                       T0SE = 0 -> Incremento na orda de subida.
                                       PSA = 0 -> Prescale aplicado ao Timer 0
                                       PS2 = 1, PS1 = 0 e PS0 = 0 -> Prescale = 1:32*/

  INTCON = 0b10100000;     /*Configura o registrador INTCON
                                     GIE = 1 (bit7) -> Habilita a interrupção global
                                     TMR0IE = 1 (bit 5)-> Habilita a interrupção do Timer 0
                                     TMR0IF = 0 (bit 2)-> Flag de interrupção do Timer 0 desligado */

  TMR0L = 100;                 //Valor Inicial para o timer 0


  while(1)
          {
          ad = adc_read(0);       //Faz a leitura do canal analógico e armazena em ad

          adc = ad/1000;           //divide o valor em ad por 1000
          D1 = digito[adc];      /*busca na matriz o dígito que será o resultado da
                                      ...divisão acima e o coloca na variável por1*/
          adc = (ad/100) % 10;     /*divide o valor em ad por 100 e o resultado é
                                      ...dividido por 10 e somente utilizado o resto da
                                      ...última divisão.*/
          D2 = digito[adc];      /*busca na matriz o dígito que será o resultado da
                                      ...divisão acima e o coloca na variável por2*/
          adc = (ad/10) % 10;      /*divide o valor em ad por 10 e o resultado é
                                     ...dividido por 10 e somente utilizado o resto da
                                      ...última divisão.*/
          D3 = digito[adc];      /*busca na matriz o dígito que será o resultado da
                                      ...divisão acima e o coloca na variável por3*/
          adc = ad % 10;           /*divide o valor em ad por 10 e somente utilizado
                                      ...o resto da última divisão.*/
          D4 = digito[adc];      /*busca na matriz o dígito que será o resultado da
                                      ...divisão acima e o coloca na variável por4*/

          delay_ms(1000);          //Atraso de 1000ms ou 1 segundo
         }
}


[ze2]

posso..?

Código: Selecionar todos

unsigned char const digito[10] =
               {0b00111111,    //Dígito 0
                0b00000110,    //Dígito 1
                0b01011011,    //Dígito 2
                0b01001111,    //Dígito 3
                0b01100110,    //Dígito 4
                0b01101101,    //Dígito 5
                0b01111101,    //Dígito 6
                0b00000111,    //Dígito 7
                0b01111111,    //Dígito 8
                0b01101111     //Dígito 9
               };

Código: Selecionar todos

unsigned char conta, k=1;
void interrupt()
{
PORTE=0;//melhor apagar os displays antes. evita "fantasmas"
PORTD=digito[s[conta]];//Coloca na PORTD o valor referente ao dígito da função do outro post
PORTE=k; //Aciona o k display e desliga os demais
k<<=1; //próximô
  conta++;                        //Incrementa variável
  if (conta > 3) {conta = 0;k=1;}        //Se variável for maior que 3, então atribui o valor 0 a ela e reaponta pro display 0

...
...
}

Código: Selecionar todos

main()
{
unsigned int a;
...
...
for(;;){
a=adcread(0)/30; //p.ex.
decompor(a);
}

[valecovo]

Então é assim.
Vou contar-vos a história toda para que melhor possam perceber a minha intenção.
Há dias construi uma fonte variável de 2 a 30 voltes. Para “complicar” a situação, resolvi instalar um voltímetro. Então procurei na NET e encontrei um voltímetro com o PIC 16F676. Fui testar no Proteus e não funcionou. Não sei se é só no Proteus se na realidade também não funciona. Como não funcionou na simulação fiquei com medo de montar e depois não funcionar.
Foi assim que resolvi fazer a minha programação e como estava a tratar do PIC 16F676, que já comprei, resolvi fazer a programação para este PIC. No entanto parece-me que este PIC é muito fraquinho (poucas capacidades).
Aqui fica o programa feito para LCD. Na simulação funciona bem, porque não é necessário separar os números. Agora eu estava a pensar montar o voltímetro com display de 7 segmentos (que tenho vários), para evitar comprar um LCD. E o problema é que com display de 7 segmentos vou ter que separar os números. Porém, só vou ter necessidade de apresentar 3 dígitos (unidade, dezena e uma casa decimal). Se fosse um número inteiro não tinha problemas, mas a virgula está a atrapalhar-me.

Código: Selecionar todos

//Com display de anodo comum

#include <16F676.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC_IO                 //Oscilador interno
#FUSES PUT                      //Power Up Timer
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOCPD                    //No EE protection

#use delay(clock=4000000)

#include <PIC16F676_Voltimetro_7Segmentos_03.h>

// DEFINIÇÃO E INICIALIZAÇÃO DOS PORTS

#use fast_io(a)
#use fast_io(c)

#byte porta = 0x05
#byte portc = 0x07

unsigned int cem, dez, uni;
int num;
////////// DISPLAY DAS CENTENAS
display_centena()
{
   switch(uni)
   {
      case 0:
      {
         porta = 0b00000001;
         portc = 0b00111111;
      }
      break;
      case 1:
      {
         porta = 0b00000001;
         portc = 0b00000110;
      }
      break;
      case 2:
      {
         porta = 0b00001001;
         portc = 0b00011011;
      }
      break;
      case 3:
      {
         porta = 0b00001001;
         portc = 0b01001111;
      }
      break;
      case 4:
      {
         porta = 0b00001001;
         portc = 0b00100110;
      }
      break;
      case 5:
      {
         porta = 0b00001001;
         portc = 0b00101101;
      }
      break;
      case 6:
      {
         porta = 0b00001001;
         portc = 0b00111101;
      }
      break;
      case 7:
      {
         porta = 0b00000001;
         portc = 0b00000111;
      }
      break;
      case 8:
      {
         porta = 0b00001001;
         portc = 0b00111111;
      }
      break;
      case 9:
      {
         porta = 0b00001001;
         portc = 0b00101111;
      }
      break;
   }
   delay_ms(500);
}

////////// DISPLAY DAS DEZENAS
display_dezena()
{
  // dez = (num%100);
  // dez = (dez/10) - ((dez%10)/10);
   switch(dez)
   {
      case 0:
      {
         porta = 0b00000010;
         portc = 0b00111111;
      }
      break;
      case 1:
      {
         porta = 0b00000010;
         portc = 0b00000110;
      }
      break;
      case 2:
      {
         porta = 0b00001010;
         portc = 0b00011011;
      }
      break;
      case 3:
      {
         porta = 0b00001010;
         portc = 0b01001111;
      }
      break;
      case 4:
      {
         porta = 0b00001010;
         portc = 0b00100110;
      }
      break;
      case 5:
      {
         porta = 0b00001010;
         portc = 0b00101101;
      }
      break;
      case 6:
      {
         porta = 0b00001010;
         portc = 0b00111101;
      }
      break;
      case 7:
      {
         porta = 0b00000010;
         portc = 0b00000111;
      }
      break;
      case 8:
      {
         porta = 0b00001010;
         portc = 0b00111111;
      }
      break;
      case 9:
      {
         porta = 0b00001010;
         portc = 0b00101111;
      }
      break;
   }
   delay_ms(500);
}

////////// DISPLAY DAS UNIDADES
display_unidade()
{
   //uni = num%10;
   switch(uni)
   {
      case 0:
      {
         porta = 0b00000100;
         portc = 0b00111111;
      }
      break;
      case 1:
      {
         porta = 0b00000100;
         portc = 0b00000110;
      }
      break;
      case 2:
      {
         porta = 0b00001100;
         portc = 0b00011011;
      }
      break;
      case 3:
      {
         porta = 0b00001100;
         portc = 0b01001111;
      }
      break;
      case 4:
      {
         porta = 0b00001100;
         portc = 0b00100110;
      }
      break;
      case 5:
      {
         porta = 0b00001100;
         portc = 0b00101101;
      }
      break;
      case 6:
      {
         porta = 0b00001100;
         portc = 0b00111101;
      }
      break;
      case 7:
      {
         porta = 0b00000100;
         portc = 0b00000111;
      }
      break;
      case 8:
      {
         porta = 0b00001100;
         portc = 0b00111111;
      }
      break;
      case 9:
      {
         porta = 0b00001100;
         portc = 0b00101111;
      }
      break;
   }
   delay_ms(500);
}

////////// PROGRAMA PRINCIPAL
void main()
{
   set_tris_a(0b11111000);
   set_tris_c(0b11111111);

   porta = 0;  // Reseta portas
   portc = 0;
   
   setup_adc_ports(NO_ANALOGS);
   uni = 0;
   dez=0;
   cem=0;
   
   while(1)
   {
      for(num=0;num<99;num++)
      {
         uni++;
         if(uni>9)
         {
            uni=0;
            dez++;
            if(dez>9)
            {
               dez=0;
               cem++;
               if(cem>9)
               {
                  cem=0;
               }
            }
         }
         delay_ms(1);
         display_centena();
         display_dezena();
         display_unidade();
      }
   }
}
/////////// FIM DO PROGRAMA

[ze2]

olá. na minha neutra opinião estás a complicar algo relativamente simples. não propositalmente, óbvio, mas devido às tuas limitações (sem ofensa). Vamos por partes
permiti-me usar o exemplo do amigo tcp pois apesar de não muito otimizado, é mais didático
digamos que o resultado da saída ad seja a variável unsigned int adc 512

Código: Selecionar todos

adc=adcread(0)/3; //resultado máximo seria pouco maior que 300. e como vais medir até 30V apenas, vamos aproximar (depois tu ajustas) por hora não te preocupes com virgula

adc = ad/100     /*divide o valor em ad por 100 //....(//----> ou seja vai de 0 a 3)

D1 = digito[adc];      /*busca na matriz o dígito que será o resultado da
                                      ...divisão acima e o coloca na variável D1/
adc = (ad/10) % 10;      /*divide o valor em ad por 10 e o resultado é ....(//----> ou seja vai de 0 a 9)
                                     ...dividido por 10 e somente utilizado o resto da
                                     ...última divisão.*/
D2 = digito[adc];      /*busca na matriz o dígito que será o resultado da
                                      ...divisão acima e o coloca na variável D2*
adc = ad % 10;           /*divide o valor em ad por 10 e somente utilizado ....(//----> ou seja vai de 0 a 9)
                                      ...o resto da última divisão.*/
D3 = digito[adc];      /*busca na matriz o dígito que será o resultado da
                                      ...divisão acima e o coloca na variável D3*/

p.ex. se adc=170 teremos D1=0b00000110,D2=00000111,D3=0b00111111 --> consegues perceber de onde vêm estes dados? se sim pronto! questão resolvida e já podes prosseguir sozinho

isso teoricamente já deve te dar muita luz sobre a questão inicial que é separar os numeros com um adicional bacana de já prepará-los (decodificá-los) para o display.
Após perceberes estes princípios, terás maior facilidade em prosseguir nesta jornada. Caso desejes, (talvez, na medida do possível) possamos (posso) acompanhar-te. Sugiro que faça uma simulação no proteus ou até mesmo no mplab. coloque algus break points e veja a mágica acontecer com as variáveis.
Com relação ao pic16f676 sim ele daria conta. Só não tem pinos suficientes. Terias que usar um shift register externo (já o fiz) Porém acho que não é o momento pra isso.

Ah... há um detalhe importante: só sei que nada sei. rs

abç

[cfreund]

Você está tendo problemas em calcular décimos? Se for isso, poste o código que faz aquisição e tratamento do ADC.

[valecovo]

Olá a todos

Bom, para quem está a iniciar é complicado. Mas já estou a entender um pouco. Só falta testar.

O código que eu fiz para aquisição ADC e para LCD, funciona bem. Fica aqui a função principal.

Código: Selecionar todos

void main()
{
   unsigned long int digital; // unsigned long int para ADC maior 10 bits
   float tensao;
   
   set_tris_a(0b11111111);
   set_tris_c(0b00000000);

   porta = 0;  // Reseta portas
   portc = 0;

   inicializa_lcd();    // Inicializa o LCD
      setup_adc(ADC_CLOCK_INTERNAL);    //enables the a/d module and sets the clock to internal adc clock
      setup_adc_ports(sAN1);      //sets all the adc pins to analog
      setup_adc(adc_clock_div_2);
      set_adc_channel(1);      //the next read_adc call will read channel
      delay_ms(1);            //a small delay is required after setting the channel
     
   while(true)
   {
      digital=read_adc();
      delay_ms(1);
      tensao=5*(float)digital/1023;
      caracter_inicio(1,1);
      printf(escreve_lcd,"Tensao: %2.2f",tensao);
     // caracter_inicio(2,1);
     // printf(escreve_lcd,"ADC: %4Lu",digital);  //%4Lu para unsigned long int
      delay_ms(1); 
   }
}

[valecovo]

Fiz assim (segue o código). Só que queria fazer com o PIC16F676 e com display de 7 segmentos e não consigo resolver, porque o PIC tem poucos pinos e eu não consigo configurá-lo para que dê certo.

Código: Selecionar todos

#include <16F676.h>

#device ADC=10

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC_IO                 // osc interno
#FUSES PUT                      //Power Up Timer
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOCPD                    //No EE protection

#use delay(clock=1000000)
//Com display de catodo comum

// DEFINIÇÃO E INICIALIZAÇÃO DOS PORTS

#use fast_io(a)
#use fast_io(c)

#byte porta = 0x05
#byte portc = 0x07

unsigned int dez, uni, dec;

////////// Apresentar digito das dezenas
void dezenas()
{
   output_high(pin_a1);
   switch(dez)
   {
      case 0:
      {
         portc = 0b111111;
      }
      break;
      case 1:
      {
         portc = 0b000110;
      }
      break;
      case 2:
      {
         output_high(pin_a5);
         portc = 0b011011;
      }
      break;
      case 3:
      {
         output_high(pin_a5);
         portc = 0b001111;
      }
      break;
      case 4:
      {
         output_high(pin_a5);
         portc = 0b100110;
      }
      break;
      case 5:
      {
         output_high(pin_a5);
         portc = 0b101101;
      }
      break;
      case 6:
      {
         output_high(pin_a5);
         portc = 0b111101;
      }
      break;
      case 7:
      {
         portc = 0b000111;
      }
      break;
      case 8:
      {
         output_high(pin_a5);
         portc = 0b111111;
      }
      break;
      case 9:
      {
         output_high(pin_a5);
         portc = 0b101111;
      }
      break;
   }
   delay_ms(1);
   output_low(pin_a1);
   output_low(pin_a5);
}

////////// Apresentar digito
void unidades()
{
   output_high(pin_a2);
   switch(uni)
   {
      case 0:
      {
         portc = 0b111111;
      }
      break;
      case 1:
      {
         portc = 0b000110;
      }
      break;
      case 2:
      {
         output_high(pin_a5);
         portc = 0b011011;
      }
      break;
      case 3:
      {
         output_high(pin_a5);
         portc = 0b001111;
      }
      break;
      case 4:
      {
         output_high(pin_a5);
         portc = 0b100110;
      }
      break;
      case 5:
      {
         output_high(pin_a5);
         portc = 0b101101;
      }
      break;
      case 6:
      {
         output_high(pin_a5);
         portc = 0b111101;
      }
      break;
      case 7:
      {
         portc = 0b000111;
      }
      break;
      case 8:
      {
         output_high(pin_a5);
         portc = 0b111111;
      }
      break;
      case 9:
      {
         output_high(pin_a5);
         portc = 0b101111;
      }
      break;
   }
   delay_ms(1);
   output_low(pin_a2);
   output_low(pin_a5);  //Pino do segmento "g"
}

////////// Apresentar digito
void decimas()
{
   output_high(pin_a4);
   switch(dec)
   {
      case 0:
      {
         portc = 0b111111;
      }
      break;
      case 1:
      {
         portc = 0b000110;
      }
      break;
      case 2:
      {
         output_high(pin_a5);
         portc = 0b011011;
      }
      break;
      case 3:
      {
         output_high(pin_a5);
         portc = 0b001111;
      }
      break;
      case 4:
      {
         output_high(pin_a5);
         portc = 0b100110;
      }
      break;
      case 5:
      {
         output_high(pin_a5);
         portc = 0b101101;
      }
      break;
      case 6:
      {
         output_high(pin_a5);
         portc = 0b111101;
      }
      break;
      case 7:
      {
         portc = 0b000111;
      }
      break;
      case 8:
      {
         output_high(pin_a5);
         portc = 0b111111;
      }
      break;
      case 9:
      {
         output_high(pin_a5);
         portc = 0b101111;
      }
      break;
   }
   delay_ms(1);
   output_low(pin_a4);  //Pino de ativacao das decimas
   output_low(pin_a5);  //Pino do segmento "g"
}

////////// PROGRAMA PRINCIPAL
void main()
{
   unsigned long int digital, inte; // unsigned long int para ADC maior 10 bits
   float tensão;
   dez=0;      //Dezenas
   uni=0;      //Unidades
   dec=0;      //Parte decimal
   
   set_tris_a(0b001001);
   set_tris_c(0b000000);

   porta = 0;  // Reseta portas
   portc = 0;
   
   DISABLE_INTERRUPTS(GLOBAL);
   setup_comparator(NC_NC);
   setup_vref(FALSE);
     
   setup_adc(ADC_CLOCK_INTERNAL);    //enables the a/d module and sets the clock to internal adc clock
   setup_adc_ports(sAN0);      //sets all the adc pins to analog
   setup_adc(adc_clock_div_2);
   set_adc_channel(0);      //the next read_adc call will read channel
   delay_ms(1);            //a small delay is required after setting the channel
     
   while(true)
   {
      //digital=read_adc();
      digital=1228;
      delay_ms(1);
      tensão=5*(float)digital/1023;
      tensão=tensao*10;   //Se tensão=23.657, fica 236.57
      inte=(long int)tensão*1;   //Fica 236
     
      dec=inte%10;   //divide por 10 e atribui o resto para a variável (6).
      inte=inte/10;  //inte = 23
      uni=inte%10;   //uni = 3
      dez=inte/10;   //dez = 2
     
      dezenas();     //Escreve o digito das dezenas
      unidades();    //Escreve o digito das unidades
      decimas();     //Escreve o digito das decimas
   }
}
/////////// FIM DO PROGRAMA

[ze2]

meu caro distante amigo virtual quasixará. voce precisa de mais ajuda do que imaginei. (sem ofensa, de novo). No entanto não te acanhes em reperguntar quantas vezes desejares.
Quem pergunta é tolo por alguns minutos. Quem não, é tolo pra sempre.
Vamo lá...
quanto a separar os dados veja de uma outra forma talvez + didática ao invés de usar %:
digamos que inte=123

Código: Selecionar todos

cen=inte/100;
dez=(inte-cen*100)/10;
uni=inte-cen*100-dez*10;

Percebes desta forma os valores de cen=1,dez=2,uni=3? Após afirmares que compreendeste MESMO terá valida a pena todo meu 'investimento'. Avaliarei a viabilidade da continuidade.

Com relação ao 676 dei uma revisada nos pinos e percebi que SIM é possível acionar os 7 (sete) segmentos e o ponto decimal voce deixa constante. E uma entrada analógica tu usarias como voltimetro. Isso ocuparia TODOS seus pinos mas cumpriria a missão. Apesar de seus ports de 6 bits, podes usar um pino de outro port. Isso é relativamente fácil (ou nem tanto). Veja:

Código: Selecionar todos

PORTC=cen>>1; //bit6...1
RA2=cen;//bit0

Detalhe : tu não deves forçar o 676 a trabalhar com float (acho que nem consegue). Use no máximo int

sucessos!

[cfreund]

zé,

O operador módulo (%), faz exatamente o que você fez, mas de forma direta e mais elegante.

[cfreund]

//digital=read_adc();
digital=1228;
delay_ms(1);
tensão=5*(float)digital/1023;
tensão=tensao*10; //Se tensão=6.002, fica 60.02
inte=(long int)tensão*1; //Fica 60

Faça:

digital=1228; //digital=read_adc();
delay_ms(1);
inte=(unsigned long int)50*digital/1023; //Fica 60

O efeito será o mesmo.

[ze2]

sabemos disso caro amigo cfeund. note-se os demais exemplos que postei. No entanto, pelo pouco que senti do amigo, ele "ainda" não tem intimidades com estas "elegâncias". Portando minha proposta foi só didática mesmo. Cabe aqui uma observação: me lembro vagamente que aquelas contas eram executadas com menos recursos do que com % pelo menos num mc de 8bits. Qualquer dia confiro...

[cfreund]

Entendo, mas fiz a observação justamente por não encontrar nada de errado com essa parte do código.

Realmente, existem alternativas mais eficientes que o %, mas não é o objetivo.