RESULTADO DE UM MULTIPLICACAO E TAMANHO DO NUMERO

Ver o tópico anterior Ver o tópico seguinte Ir em baixo

RESULTADO DE UM MULTIPLICACAO E TAMANHO DO NUMERO

Mensagem  davilara em Dom Set 26, 2010 9:22 pm

OLÁ PESSOAL;
JA ESTA 10 A 0 PRO PIC...HEHEHEHHEH..TO APANHANDO FEIO..HEHEH
É O SEGUINTE:
1-FIZ UMA PROGRAMA QUE CALCULA O VOLUME DE ACORDO COM OS VALORES DIGITADOS PELO USUÁRIO.
EU SOLICITO QUE O USUARIO ENTRE COM OS VALORES: ESPESSURA, LARGURA E COMPRIMENTO.
QUANDO EU DIGITO ALGUM VALOR NESSES CAMPOS DE FORMA QUE O RESULTADO NAO DE MAIS QUE 10 A CONTA SAI CERTA.
POR EXEMPLO: ESPESSURA: 2; LARGURA: 2 E COMPRIMENTO: 2. AI ELE ME DA A RESPOSTA CORRETA, OU SEJA 8.
AGORA, QUANDO EU INSERO VALORES DE FORMA QUE O RESULTADO VAI DAR MAIS QUE 10, AI DA UM RESULTADO MUITO ESTRANHO.
POR EXEMPLO: ESPESSURA: 3 LARGURA: 3 E COMPRIMENTO: 2. AI ELE ME DA O RESULTADO DE 81 EM VEZ DE ME DAR 12 COMO RESULTADO. MUITO ESTRANHO.

2-COMO EU FACO PRA LIMINTAR O TAMANHO DE UMA VARIAVEL. POR EXEMPLO: A VARIAVEL ESPESSURA NO PODE TER 3 ALGARISMOS: EXEMPLO: 156. QUANDO ELE ALCANCAR OS 3 ALGARISMO DEVE PARA DE INCREMENTAR. JA TENTEI AQUELE OPCAO DE ESPESSURA [3], MAS NAO DEU CERTO.
ALGUEM PODERIA ME AJUDAR NESSAS DUAS DUVIDAS?
VALEWWW......

davilara

Mensagens : 7
Data de inscrição : 27/10/2009

Ver perfil do usuário

Voltar ao Topo Ir em baixo

Re: RESULTADO DE UM MULTIPLICACAO E TAMANHO DO NUMERO

Mensagem  Bruno S. Avelar em Seg Set 27, 2010 4:42 pm

Olá Davilara,

Preocupa não que vamos virar esse jogo e ganhar de goleada em cima do PIC.
Quanto ao problema 1:

Eu preciso de mais informações para poder te indicar qual o problema do seu código. Primeiro, como voce entra os valores de espessura, largura e comprimento? Preciso saber onde voce mostra este resultado para o usuário (se é no LCD ou no 7 seg). Você poderia postar parte do seu código aqui no forum para eu dar uma olhada? (basta colocar [.c.o.de] antes do seu código e [/.c.o.de] no final do seu código na hora de postar).

Quanto ao problema 2:

int espessura [3] é um vetor de 3 inteiros cada um podendo receber números de -32,768 a 32,767. Logo não resolve seu problema.
Para resolver podemos pensar em um algoritmo que impeça que a variável espessura seja incrementada se for maior do que 999 (maior número de 3 dígitos). A solução para impedir que decremente abaixo de 0 é similar.

Algoritmo: Suponha que seu programa esta no estado de receber o valor da espessura do usuário. Se o botão 1 for pressionado o programa olhará se espessura < 999 caso seja ele fará espessura = espessura +1 caso contrário ele não fará nada (nao passando espessura para 1000) . Abaixo um diagrama de blocos onde B1 é o botão1, esp é a espessura:



Implementada essa solução ficaria mais ou menos assim:

Código:

int esp = 0;
while (1)
{
    ...
    ...
    ...
    if(B1 == 1)
    {
        if(esp < 999)
        {
              esp = esp + 1;
        }
      }
      ...
      ...
}

Já te adiantando, você vai descobrir que devido a chave por ser mecanica ela possui um tempo de instabilidade onde a sua esp irá contar varios números em um único clique (bouncer). O que voce deve fazer para resolver este problema é chamado de debouncing e uma das formas de implementar é dar um delay antes de incrementar o esp. Caso voce tenha dúvida nisso é só perguntar que detalho mais para você ok?

Espero ter ajudado,
Bruno S. Avelar
avatar
Bruno S. Avelar
Admin

Mensagens : 74
Data de inscrição : 26/07/2009
Idade : 32
Localização : Belo Horizonte MG

Ver perfil do usuário http://picminas.forumeiros.com

Voltar ao Topo Ir em baixo

codigo do programa

Mensagem  davilara em Qui Set 30, 2010 8:15 am

Olá Bruno.
Estou te enviando o codigo para vc dar uma olhada nele.
O os dados são escrito em um display de LCD 4 x 20.

Código:

/******************************************************************************
 *
 *            DISPOSITIVO DE CONTROLE DE ESPIGAR AGUA
 *
 ******************************************************************************
 * Nome do Arquivo:    main.c
 * Dependencias:       Veja a seção INCLUDES abaixo
 * Processador:         PIC18F4550
 * Opção de Clock:      HS 20MHz (externo) - CPU:48MHz
 * Compilador:           C18 v3.32 ou superior
 * Empresa:           Metal Mecanica
 *
 * Plataforma:         v3.0
 *
 * Descrição:      Controlar a vazao de agua da maquina recicladora
 *              em funcao de algumas variaveis de entrada
 *
 *               
 *               O sistema deve apresentar o seguinte comportamento:
 *                  1)
 *         
 *
 *                  2)
 *
 *                  3
 *                              
 *               Dicas:
 *                  - Utilizar a biblioteca adc.h. Para maiores informações
 *                    sobre esta biblioteca consultar o conteúdo do arquivo:
 *                    C:/MCC18/doc/periph-lib/AD Converter.htm.
 *                  - Utilizar as funções da biblioteca de usuário de display
 *                    de LCD
 *
 *****************************************************************************/

/** I N C L U D E S **********************************************************/
#include <p18cxxx.h>      // Necessário para que o compilador adicione a biblioteca
                     // com as definições do PIC selecionado no projeto, neste
                     // caso, o modelo 18F4550.


//#include <conio.h>                     

#include <stdlib.h>      //Biblioteca com rotinas de conversão de tipos em string
                  // mais informações nos arquivos de ajuda da biblioteca C18
                  // presentes na propria pasta de instalação, por exemplo,
                  // C:\MCC18\doc\hlpC18Lib.chm
                  // Procure pelo item: "Data Conversion Functions"

//#include <stdio.h>
         
#include <string.h>      //Biblioteca com rotinas de manipulação de string
                  // mais informações nos arquivos de ajuda da biblioteca C18
                  // presentes na propria pasta de instalação, por exemplo,
                  // C:\MCC18\doc\hlpC18Lib.chm
                  // Procure pelo item: "Memory and String Manipulation Functions   
                  
#include "my_xlcd.h"   // Biblioteca com de rotinas para usar o display LCD no
                  // Kit PICMINAS v2.0

#include <delays.h>      // Biblioteca padrão de rotinas de atraso do C18 Microchip
                  // mais informações nos arquivos de ajuda da biblioteca C18
                  // presentes na propria pasta de instalação, por exemplo,
                  // C:\MCC18\doc\hlpC18Lib.chm
                  // Procure pelo item: "Delay Functions"


#include <eep.h>       // Biblioteca C18 com funções para a memória EEPROM interna do PIC                  
                  
                                                      

/** D E F I N E S ************************************************************/

#define BUZZER            PORTCbits.RC1
#define TECLA_1       PORTAbits.RA1
#define TECLA_2       PORTAbits.RA2
#define TECLA_3       PORTAbits.RA3
#define TECLA_4       PORTAbits.RA4
#define TECLA_5       PORTAbits.RA5
#define TECLA_6       PORTEbits.RE0
#define TECLA_7       PORTCbits.RC2
#define TECLA_8       PORTCbits.RC0
#define TECLA_9       PORTBbits.RB7
#define TECLA_0       PORTBbits.RB6
#define BOTAO_ENTER       PORTEbits.RE2
#define BOTAO_CLEAR    PORTAbits.RA0


/** V A R I A V E I S  G L O B A I S ****************************************/


/** V A R I A V E I S  TIPOS ESTRINGS ****************************************/
int str_numero_esp;
int str_numero_larg;
int str_numero_comp;
int str_resultado;

int numero_esp=0.00;
int contador_esp=1.00;
int numero_larg=0.00;
int contador_larg=1.00;
int numero_comp=0.00;
int contador_comp=1.00;
int resultado=0.00;



/**  P R O T O T I P O S  P R I V A D O S ***********************************/
void ConfiguraSistema (void);


/** F U N C O E S ************************************************************/

/******************************************************************************
 * Funcao:           void main(void)
 * PreCondition:     Nenhuma
 * Entrada:        Nenhuma
 * Saída:             Nenhuma
 * Descrição:      Função principal do programa.
 *****************************************************************************/
void main(void)
{


   ConfiguraSistema();             //Configura as portas e periféricos usados no projeto.
   
   INTCONbits.GIE=1;       // Habilita TODAS as interrupções
     
   WriteCmdXLCD(0b00000001);      //Comando: Clear Display


   SetDDRamAddr(2);                //Seleciona o inicio da linha 1, COLUNA 2
   putrsXLCD("PRESSIONE ENTER");    //Escreve msg no LCD

   
   SetDDRamAddr(68);                //Seleciona o inicio da linha 2, COLUNA 4
   putrsXLCD("PARA INICIAR");      //Escreve msg no LCD

   BUZZER=0;

   
                      //Fim das mensagens iniciais.


     while(1)  //LUPE INFINITO 1   
     {

       if (BOTAO_ENTER==1)      //IF 1. BOTAO ENTER
       {
      BUZZER=1;
      Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
      BUZZER=0;
        Delay10KTCYx(216);

      WriteCmdXLCD(0b00000001);           //Comando: Clear Display
      
      SetDDRamAddr(0);                     //Seleciona o inicio da linha 1, COLUNA 1
      putrsXLCD("Informe os Valores.");      //Escreve msg no LCD

      SetDDRamAddr(64);                      //Seleciona o inicio da linha 2, COLUNA 1
      putrsXLCD("Esp:  cm");                      //Escreve msg no LCD

      SetDDRamAddr(74);                  //Seleciona o inicio da linha 2, COLUNA 11
      putrsXLCD("Larg:  cm");                  //Escreve msg no LCD

      SetDDRamAddr(84);                  //Seleciona o inicio da linha 3, COLUNA 1
      putrsXLCD("Comp:  cm");                  //Escreve msg no LCD

      SetDDRamAddr(94);                  //Seleciona o inicio da linha 3, COLUNA 11
      putrsXLCD("Vol:  cm2");               //Escreve msg no LCD

      WriteCmdXLCD(0b000100);            // cursor se move para esquerda

      WriteCmdXLCD(0b00001100);            // sem cursor piscando


                 

while(2)                    //LUPE INFINITO 2 - BLOCO DE DADOS ESPESSURA
{

TECLA_1=1;
TECLA_2=1;
TECLA_3=1;
TECLA_4=1;
TECLA_5=1;
TECLA_6=1;
TECLA_7=0;
TECLA_8=0;
TECLA_9=0;
TECLA_0=0;


               if (TECLA_1==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp = numero_esp+ (1.0*contador_esp);
               contador_esp=contador_esp*10.0;
               }

               if (TECLA_2==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp=numero_esp+ (2.0*contador_esp);
               contador_esp=contador_esp*10.0;
               }

               if (TECLA_3==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp=numero_esp + (3.0*contador_esp);
               contador_esp=contador_esp*10.0;
               }

               if (TECLA_4==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp=numero_esp + (4.0*contador_esp);
               contador_esp=contador_esp*10.0;
               }

               if (TECLA_5==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp=(int)numero_esp + (5.0*(int)contador_esp);
               contador_esp=(int)contador_esp*10.0;
               }

               if (TECLA_6==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp=numero_esp + (6.0*contador_esp);
               contador_esp=contador_esp*10.0;
               }

               if (TECLA_7==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp=numero_esp + (7.0*contador_esp);
               contador_esp=contador_esp*10.0;
               }

               if (TECLA_8==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp=numero_esp + (8.0*contador_esp);
               contador_esp=contador_esp*10.0;
               }

               if (TECLA_9==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp=numero_esp + (9.0*contador_esp);
               contador_esp=contador_esp*10.0;
               }

               if (TECLA_0==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_esp=numero_esp + (0.0*contador_esp);
               contador_esp=contador_esp*10.0;
               }

               if (BOTAO_CLEAR==1)      //BOTAO CLEAR PARA LIMPAR
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               SetDDRamAddr(70);              //Seleciona o inicio da linha
               }

                  if (numero_esp>99)
                  {
                  numero_esp=0.0;
                  contador_esp=0.0;
                  }


                // Converte de valor numerico do codigo para uma string: str_codigo
               itoa(numero_esp, str_numero_esp);
            
               // Seleciona o endereço 0x49 do display para iniciar a escrita
               SetDDRamAddr(70);
      
               // Escreve a string com o valor do codigo no display LCD
               putsXLCD(str_numero_esp);

if (BOTAO_ENTER==1) //IF 2. BOTAO ENTER
{
BUZZER=1;
Delay10KTCYx(255); //BLOCO PARA APITAR O BUZZER   
BUZZER=0;
Delay10KTCYx(216);



while(3) //BLOCO DE DADOS LARGURA
{


               if (TECLA_1==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=numero_larg + (1.0*contador_larg);
               contador_larg=contador_larg*10.0;
               }

               if (TECLA_2==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=numero_larg + (2.0*contador_larg);
               contador_larg=contador_larg*10.0;
               }

               if (TECLA_3==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=numero_larg + (3.0*contador_larg);
               contador_larg=contador_larg*10.0;
               }

               if (TECLA_4==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=numero_larg + (4.0*contador_larg);
               contador_larg=contador_larg*10.0;
               }

               if (TECLA_5==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=(int)numero_larg + (5.0*(int)contador_larg);
               contador_larg=(int)contador_larg*10.0;
               }

               if (TECLA_6==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=numero_larg + (6.0*contador_larg);
               contador_larg=contador_larg*10.0;
               }

               if (TECLA_7==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=numero_larg + (7.0*contador_larg);
               contador_larg=contador_larg*10.0;
               }

               if (TECLA_8==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=numero_larg + (8.0*contador_larg);
               contador_larg=contador_larg*10.0;
               }

               if (TECLA_9==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=numero_larg + (9.0*contador_larg);
               contador_larg=contador_larg*10.0;
               }

               if (TECLA_0==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_larg=numero_larg + (0.0*contador_larg);
               contador_larg=contador_larg*10.0;
               }


                // Converte de valor numerico do codigo para uma string: str_codigo
               itoa(numero_larg, str_numero_larg);
            
               // Seleciona o endereço 0x49 do display para iniciar a escrita
               SetDDRamAddr(81);
      
               // Escreve a string com o valor do codigo no display LCD
               putsXLCD(str_numero_larg);

if (BOTAO_ENTER==1) //IF 3. BOTAO ENTER
{
BUZZER=1;
Delay10KTCYx(255); //BLOCO PARA APITAR O BUZZER   
BUZZER=0;
Delay10KTCYx(216);

while(4) //BLOCO DE DADOS COMPRIMENTO
{

               if (TECLA_1==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=numero_comp+ (1.0*contador_comp);
               contador_comp=contador_comp*10.0;
               }

               if (TECLA_2==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=numero_comp+ (2.0*contador_comp);
               contador_comp=contador_comp*10.0;
               }

               if (TECLA_3==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=numero_comp+ (3.0*contador_comp);
               contador_comp=contador_comp*10.0;
               }

               if (TECLA_4==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=numero_comp+ (4.0*contador_comp);
               contador_comp=contador_comp*10.0;
               }

               if (TECLA_5==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=(int)numero_comp+ (5.0*(int)contador_comp);
               contador_comp=(int)contador_comp*10.0;
               }

               if (TECLA_6==0)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=numero_comp+ (6.0*contador_comp);
               contador_comp=contador_comp*10.0;
               }

               if (TECLA_7==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=numero_comp+ (7.0*contador_comp);
               contador_comp=contador_comp*10.0;
               }

               if (TECLA_8==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=numero_comp+ (8.0*contador_comp);
               contador_comp=contador_comp*10.0;
               }

               if (TECLA_9==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=numero_comp+ (9.0*contador_comp);
               contador_comp=contador_comp*10.0;
               }

               if (TECLA_0==1)      //NUMERO 1
               {
               BUZZER=1;
               Delay10KTCYx(255);      //BLOCO PARA APITAR O BUZZER   
               Delay10KTCYx(100);      //BLOCO PARA APITAR O BUZZER
               BUZZER=0;
               numero_comp=numero_comp+ (0.0*contador_comp);
               contador_comp=contador_comp*10.0;
               }


                // Converte de valor numerico do codigo para uma string: str_codigo
               itoa(numero_comp, str_numero_comp);
            
               // Seleciona o endereço 0x49 do display para iniciar a escrita
               SetDDRamAddr(91);
      
               // Escreve a string com o valor do codigo no display LCD
               putsXLCD(str_numero_comp);


if (BOTAO_ENTER==1) //IF 3. BOTAO ENTER
{
BUZZER=1;
Delay10KTCYx(255); //BLOCO PARA APITAR O BUZZER   
BUZZER=0;
Delay10KTCYx(216);
resultado = (numero_esp * numero_larg * numero_comp);
itoa(resultado, str_resultado);
SetDDRamAddr(100);
putsXLCD(str_resultado);        // Escreve a string com o valor do codigo no display LCD
}



}//END WHILE 4
}//END IF 3
}//END WHILE 3
}//END IF 2
}//END WHILE 2
}//END IF 1
}//end while 1
}//end main

/******************************************************************************
 * Funcao:          void ConfiguraSistema(void)
 * Entrada:        Nenhuma (void)
 * Saída:          Nenhuma (void)
 * Descrição:      ConfiguraSistema é a rotina de configuração principal do PIC.
 *               Seu objetivo é configurar as portas de I/O e os periféricos
 *               do microcontrolador para que os mesmos trabalhem da maneira
 *               desejada no projeto. 
 *
 *****************************************************************************/
void ConfiguraSistema (void)
{
    // Configura todas as 13 portas analógicas ANx (portas do conversor A/D) como pinos digitais
   ADCON1 |= 0x0F;         // Todos os pinos como digital
   // No PIC18F4550 temos:
   // AN0=RA0
   // AN1=RA1
   // AN2=RA2
   // AN3=RA3
   // AN4=RA5
   // AN5=RE0
   // AN6=RE1
   // AN7=RE2
   // AN8=RB2
   // AN9=RB3
   // AN10=RB1
   // AN11=RB4
   // AN12=RB0
   
      //Configura os pinos que são usados pelo LCD 16x2 alfa-numerico
   OpenXLCD();
   
   // Configura os LEDs com saída digital

    TRISCbits.TRISC1 = 0;    // BUZZER
    TRISEbits.TRISE2 = 1;    // BOTAO_2
   TRISAbits.TRISA0 = 1;    // BOTAO_CLEAR
   TRISAbits.TRISA1 = 1;    // NUMERO 1
   TRISAbits.TRISA2 = 1;    // NUMERO 2
   TRISAbits.TRISA3 = 1;    // NUMERO 3
   TRISAbits.TRISA4 = 1;    // NUMERO 4
   TRISAbits.TRISA5 = 1;    // NUMERO 5
   TRISEbits.TRISE0 = 1;    // NUMERO 6
   TRISCbits.TRISC2 = 1;    // NUMERO 7
   TRISCbits.TRISC0 = 1;    // NUMERO 8
   TRISBbits.TRISB7 = 1;    // NUMERO 9 
   TRISBbits.TRISB6 = 1;    // NUMERO 0   


}//end ConfiguraSistema




/******************************************************************************
 * Funcao:        void ConfiguraInterrupcao(void)
 * Entrada:        Nenhuma (void)
 * Saída:          Nenhuma (void)
 * Descrição:      Função que configura as interrupções utilizadas no projeto
 *
 *****************************************************************************/



/** V E C T O R  R E M A P P I N G ******************************************/
// Seção necessária para informar ao compilador C18 onde são os novos endereços
//da memória de programa que ele deve alocar as rotinas de tratamento do evento
//de "reset" do microcontrolador.
//
//ATENÇÃO: COPIAR ESTA SEÇÃO DO CODIGO PARA TODO ARQUIVO "main.c" DOS PROJETOS
//QUE UTILIZAM O BOOTLOADER PARA GRAVAÇÃO IN-CIRCUIT.

extern void _startup (void);        // See c018i.c in your C18 compiler dir
#pragma code _RESET_INTERRUPT_VECTOR = 0x000800
void _reset (void)
{
    _asm goto _startup _endasm
}
#pragma code
/** EOF main.c ***************************************************************/


davilara

Mensagens : 7
Data de inscrição : 27/10/2009

Ver perfil do usuário

Voltar ao Topo Ir em baixo

Re: RESULTADO DE UM MULTIPLICACAO E TAMANHO DO NUMERO

Mensagem  Bruno S. Avelar em Qui Out 07, 2010 1:50 pm

Olá Davi,

Desculpe a demora para olhar seu código. As últimas semanas foram bastante ocupadas por causa de nossa exposição na INOVATEC.
Dei uma olhada no seu código e tenho alguns comentários/sugestões.

Vi que você usou nosso layout padrão, fazendo um cabeçalho bem informativo e também você incluiu bibliotecas do compilador e de usuário fazendo comentários sobre elas para outras pessoas que peguem seu código. Os defines foram bem usados com nomes que trazem a funcionalidade do hardware em que a porta do PIC esta ligada. Você está de parabéns e no caminho certo. Mantenha estas boas práticas de programação.

Você precisa estudar um pouco mais sobre programação C, pois cometeu alguns errinhos conceituais e por isto seu programa não está tendo o comportamento esperado.

1- Declaração de variáveis:

Você declarou todas as variáveis como globais. Variáveis globais são aquelas que podem ser usadas em qualquer parte do programa, pela função main ou por outras funções declaradas. Você tem que tomar alguns cuidados no uso destas variáveis e realmente usá-las quando for necessário. Existem outros dois tipos de variáveis em C (alem das globais), são as locais e as de parâmetro formal. As locais são declaradas dentro de funções e existem apenas quando as funções estão sendo executadas e as de parametro formal são aquelas que as funções recebem como parametro. No caso do seu código você deve rever suas variáveis. Várias delas deviam ser declaradas dentro da função main.

2- Tipo de variáveis.

Apesar do seu comentário falar que suas variáveis são strings elas foram declaradas do tipo int (inteiro). A linguagem C nao possui um tipo string, para isto nós usamos um vetor de caracteres (char[] ).Na verdade tipo de dado é uma maneira do computador interpretar uma certa quantidade de bits. Por exemplo char é um conjunto de bits que representam valores de -128 a +127, o tipo float representa números com casas decimais e/ou números muito grandes. Voce deve atribuir apenas números pertinentes a um tipo por exemplo int a = 10; é válido... int b = 10.0 não pois inteiro nao recebe número com casa decimal (existe uma operação chamada cast que é algo que voce vai aprender mais para frente).

3- A linha " INTCONbits.GIE=1; // Habilita TODAS as interrupções"

Voce escreveu o comentário certo nesta linha. Realmente setar este registrador habilita as interrupções. Mas Davi, seu código nao utiliza interrupções e voce nao as configura então esta linha está sobrando. Ela não faz nenhuma mudança significativa ao seu programa.

4- Estrutura de controle:

O início do seu programa está correto. Ele inicializa o sistema fazendo as configurações nescessárias e entra no loop infinito while(1) onde ele ficará rodando fazendo o que se deseja.
Mas você colocou while (2) while(3)... Não faz sentido. while(condição) é uma estrutura que faz com que o código dentro de seu bloco fique repetindo enquanto a condição seja verdadeira. Nós colocamos while(1) para que seja sempre verdade e nunca saia de lá.

5- dentro do seu while (2) voce associou valores a teclas, mas as teclas são portas digitais de entrada. Então neste ponto voce esta azendo errado. Variáveis que sao entradas digitais devem ser lidas como : if(TECLA_1==1)

Bom, de uma revisada então em tipo de variaveis, declaração de variaives e estruturas de controle. =)
Caso tenha dúvidas poste aqui no fórum que te responderei...

Espero ter ajudado,

Bruno S. Avelar
avatar
Bruno S. Avelar
Admin

Mensagens : 74
Data de inscrição : 26/07/2009
Idade : 32
Localização : Belo Horizonte MG

Ver perfil do usuário http://picminas.forumeiros.com

Voltar ao Topo Ir em baixo

Re: RESULTADO DE UM MULTIPLICACAO E TAMANHO DO NUMERO

Mensagem  Conteúdo patrocinado


Conteúdo patrocinado


Voltar ao Topo Ir em baixo

Ver o tópico anterior Ver o tópico seguinte Voltar ao Topo

- Tópicos similares

 
Permissão deste fórum:
Você não pode responder aos tópicos neste fórum