Autor Tema: esta bien estructurado?????  (Leído 2083 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Sebascl

  • PIC12
  • **
  • Mensajes: 73
esta bien estructurado?????
« en: 11 de Octubre de 2005, 14:01:00 »
Hola, me gustaria que me pudieran decir si  esta bien estructurado este programa para que funcione la interrupcion #int_rb ya que lo e probado y no me funciona.

#include <16F84A.h>
#use delay(clock=4000000)
#fuses XT
#byte port_a = 05
#byte port_b = 06

   int teclitas=0,c=0,act=0,x,panico=0,vueltas=0,valore;
   char pass[4],temp[4],teclas;

alcero()
{

}


#int_rb

teclado()
{

}

telefono()
{

}

alarma()
{

}



void main()
{
   enable_interrupts(global);
   enable_interrupts(int_rb);
   set_tris_b(0b11110010);
   set_tris_a(0x18);
   port_a=0;
   port_b=0;

   output_high(pin_a1);


   while (TRUE)
   {
      alarma();
   }
}


UN SALUDO...

Desconectado piriots

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 609
RE: esta bien estructurado?????
« Respuesta #1 en: 11 de Octubre de 2005, 14:07:00 »
La declaracion de la interrupcion es correcta. Revisa la funcion de interrupcion, el problema debe de estar alli. Has conectado las resistencias de pull-up del teclado?? Postea la rutina de interrupcion para que le hechemos una ojeada.

Salu2

Desconectado Sebascl

  • PIC12
  • **
  • Mensajes: 73
RE: esta bien estructurado?????
« Respuesta #2 en: 11 de Octubre de 2005, 16:50:00 »
hola, lo que estoy tratando de hacer es una alarma pero con mis pocos conocimientos no me funcionado muy bien, otra cosa que abia estado tratando era guardar los estados de la alarma en la eprom interna del micro pero no supe como hacerlo.

#include <16F84A.h>
#use delay(clock=4000000)
#fuses XT
#byte port_a = 05
#byte port_b = 06


   int teclitas=0,c=0,act=0,x,panico=0,vueltas=0;
   char pass[4],temp[4],teclas;

alcero()
{
   delay_ms(4);
   temp[0]=0;
   temp[1]=0;
   temp[2]=0;
   temp[3]=0;
   c=0;
   teclas=99;
}

#int_rb

teclado()
{
   port_b_pullups(true);
      port_b=1;   //blanco-azul b2
      delay_ms(2);
      if(port_b==129)   //blanco-verde b7
      {
         teclas="3";
      }
      if(port_b==65)     //verde b6
      {
         teclas="6";
      }
      if(port_b==33)     //blanco-naranja b5
      {
         teclas="9";
      }
      if(port_b==17)       //naranja b4
      {
         teclas="#";
      }
      if(port_b>1)
      {
         teclitas=3;
      }

   if(port_b==1 && teclitas==3)
   {
         if((teclas>="0" && teclas<="9") || teclas=="#")
         {
            temp[c]=teclas;
            c++;
            teclitas=0;
            teclas=99;
         }

   }


   port_b=4;   //blanco-azul b2
   delay_ms(2);
   if(port_b==132)
   {
      teclas="2";
   }
   if(port_b==68)
   {
      teclas="5";
   }
   if(port_b==36)
   {
      teclas="8";
   }
   if(port_b==20)
   {
      teclas="0";
   }
   if(port_b>4)
   {
      teclitas=2;
   }

      if(port_b==4 && teclitas==2)
   {
         if(teclas>="0" && teclas<="9")
         {
            temp[c]=teclas;
            c++;
            teclitas=0;
            teclas=99;

         }

   }


   port_b=8;
   delay_ms(2);
   if(port_b==136)
   {
      teclas="1";
   }
   if(port_b==72)
   {
      teclas="4";
   }
   if(port_b==40)
   {
      teclas="7";
   }
   if(port_b==24)
   {
      teclas="a";
   }
   if(port_b>8)
   {
      teclitas=1;
   }

   if(port_b==8 && teclitas==1)
   {
         if((teclas>="0" && teclas<="9") || teclas=="*")
         {
            temp[c]=teclas;
            //printf("%c %c --",teclas,temp[c]);
            c++;
            teclitas=0;
            teclas=99;
         }

   }

   port_b_pullups(FALSE);
   if(teclas=="#")
   {
      if(act!=1)
      {
         act=1;
         port_a=1;
      }
      alcero();
   }

      if(teclas=="a")
   {
      if(act!=1)
      {
         port_a=1;
         delay_ms(59);
         port_a=0;
         delay_ms(59);
         port_a=1;
         delay_ms(59);
         port_a=0;
         delay_ms(59);
      }
      alcero();
   }

   if(pass[c]!=temp[c])
   {
      alcero();
   }

   if(pass[0]==temp[0] && pass[1]==temp[1] && pass[2]==temp[2] && pass[3]==temp[3])
   {
               if(act==0)
               {
                  act=1;
                  port_a=1;
               }else{
                  act=0;
                  port_a=2;
               }
            delay_ms(4);
            alcero();
   }

   port_b=13;
}


cero()
{
   delay_ms(200);
   for(x=1;x<=10;x++)
   {
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
   }
}

uno()
{
   delay_ms(200);
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
}

dos()
{
   delay_ms(200);
   for(x=1;x<=2;x++)
   {
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
   }
}

tres()
{
   delay_ms(200);
   for(x=1;x<=3;x++)
   {
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
   }
}

cuatro()
{
   delay_ms(200);
   for(x=1;x<=4;x++)
   {
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
   }
}

cinco()
{
   delay_ms(200);
   for(x=1;x<=5;x++)
   {
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
   }
}

seis()
{
   delay_ms(200);
   for(x=1;x<=6;x++)
   {
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
   }
}

siete()
{
   delay_ms(200);
   for(x=1;x<=7;x++)
   {
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
   }
}

ocho()
{
   delay_ms(200);
   for(x=1;x<=8;x++)
   {
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
   }
}

nueve()
{
   delay_ms(200);
   for(x=1;x<=9;x++)
   {
      port_a=port_a-4;
      delay_ms(50);
      port_a=port_a+4;
      delay_ms(50);
   }
}



telefono()
{
   port_a=port_a+4;
   delay_ms(4000);
   cero();
   ocho();
   seis();
   tres();
   ocho();
   cero();
   seis();
   uno();
   cero();

   delay_ms(10000);
   port_a=port_a-4;
}

void main()
{
   enable_interrupts(global);
   enable_interrupts(int_rb);
   set_tris_b(0b11110000);
   set_tris_a(0x18);
   pass[0]="1";
   pass[1]="5";
   pass[2]="2";
   pass[3]="3";
   port_b=13;

   port_a=2;
   telefono();
   alcero();
   while (TRUE)
   {
      if(act==1)
      {
         switch(port_a)
         {
            case 1:  panico=1;
            break;
            case 9:  panico=1;
            break;
            case 17: panico=1;
            break;
         }

         if(panico==1)
         {
            telefono();
         }
      }
   }
}

Unos Saludos...

Desconectado Sebascl

  • PIC12
  • **
  • Mensajes: 73
RE: esta bien estructurado?????
« Respuesta #3 en: 11 de Octubre de 2005, 16:52:00 »
el codigo no es muy optimizado ya que mi forma de programar no es muy buena, pero se ase lo que se puede.



saludos....

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7912
RE: esta bien estructurado?????
« Respuesta #4 en: 11 de Octubre de 2005, 17:31:00 »
Es asi como dices...
Si quieres guardar estados en la eeprom y son bits (short int) puedes hacerlo con estas funciones, incluidas en el CCS como una libreria llamada Internal_EEprom.c.




////////////////////////////////////////////////////////////////////////////////
//// Internal EEPROM Functions
////////////////////////////////////////////////////////////////////////////////

// Purpose:    Write one bit to internal eeprom
// Inputs:     1) An eeprom address
//             2) The bit position (LSB == 0)
//             3) The bit to write
// Outputs:    None
void write_int1_eeprom(INT_EEPROM_ADDRESS address, int8 bitPosition, int1 data)
{
   int8 stored_data;

   stored_data = read_eeprom(address);

   if(data)
   {
      bit_set(stored_data, bitPosition);
   }
   else
   {
      bit_clear(stored_data, bitPosition);
   }

   write_eeprom(address, stored_data);
}


// Purpose:    Read one bit from internal eeprom
// Inputs:     1) An eeprom address
//             2) The bit position (LSB == 0)
// Outputs:    The bit read from internal eeprom
int1 read_int1_eeprom(INT_EEPROM_ADDRESS address, int8 bitPosition)
{
   return bit_test(read_eeprom(address), bitPosition);
}


// Purpose:    Write a 16 bit number to internal eeprom
// Inputs:     1) An eeprom address
//             2) The 16 bit number to write to internal eeprom
// Outputs:    None
void write_int16_eeprom(INT_EEPROM_ADDRESS address, int16 data)
{
   int8 i;

   for(i = 0; i < 2; ++i)
   {
     write_eeprom(address + i, *(&data + i));
   }
}




Espero te sirva!!Sonrisa GiganteSonrisa GiganteSonrisa Gigante
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado Sebascl

  • PIC12
  • **
  • Mensajes: 73
RE: esta bien estructurado?????
« Respuesta #5 en: 11 de Octubre de 2005, 17:37:00 »
hola y gracias por la respuesta pero mi problema es que como no se ingles no las entiendo.


grax...

saludos..

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7912
RE: esta bien estructurado?????
« Respuesta #6 en: 12 de Octubre de 2005, 06:38:00 »
Escrito originalmente por MGLSOFT
Es asi como dices...
Si quieres guardar estados en la eeprom y son bits (short int) puedes hacerlo con estas funciones, incluidas en el CCS como una libreria llamada Internal_EEprom.c.




////////////////////////////////////////////////////////////////////////////////
//// Internal EEPROM Functions
////////////////////////////////////////////////////////////////////////////////

// Proposito: Escribe un solo bit en la EEPROM interna
// Entradas:     1) Una direccion EEPROM
//             2) La posicion del bit (LSB == 0) (bit menos significativo == 0)
//             3) El bit a escribir
// Salidas:    Ninguna
void write_int1_eeprom(INT_EEPROM_ADDRESS address, int8 bitPosition, int1 data)
{
   int8 stored_data;  //declara una variable local

   stored_data = read_eeprom(address); //carga el valor guardado en EEPROM a esa variable

   if(data)    // verifica el valor del bit
   {
      bit_set(stored_data, bitPosition);  // si es 1 lo escribe en la variable
   }
   else   // si es 0 tambien lo escribe en la variable, en la posicion indicada
   {
      bit_clear(stored_data, bitPosition); //de esa forma solo cambia ese bit
   }

   write_eeprom(address, stored_data);  // por ultimo vuelve a guardar la variable en EEPROM
}


// Proposito:    Lee un bit desde la EEPROM interna
// Entradas:     1) Una direccion EEPROM
//             2) La posicion del bit (LSB == 0) (bit menos significativo == 0)
// Salidas:    El bit a leer desde la EEPROM interna
int1 read_int1_eeprom(INT_EEPROM_ADDRESS address, int8 bitPosition)
{
   return bit_test(read_eeprom(address), bitPosition);
// Aqui solamente la funcion retorna el valor del bit que se quiere leer
}




Espero te sirva!!Sonrisa GiganteSonrisa GiganteSonrisa Gigante


A ver si puedo... mira ahora comentado...Sonrisa GiganteSonrisa Gigante
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado Sebascl

  • PIC12
  • **
  • Mensajes: 73
RE: esta bien estructurado?????
« Respuesta #7 en: 12 de Octubre de 2005, 13:52:00 »
gracias mglsoft voy a probarlo a ver que tal, y otra cosa me podrian explicar como uso la kdb.c del pcw que no la entiendo para configurarla para usar un teclado de 3columnas y 4 filas.




gracias y saludos....