Interrupcion RBO y RB4..RB7 no anda !

[gustav03]

tenco el siguiente codigo :

#include <16F84A.h>
#fuses XT,NOWDT
#use fast_io(A)
#use delay( clock = 4000000 )    /* reloj de 4 MHz */
#byte puerto_b = 06          /* dirección del puerto B */
#byte puerto_a = 05            /* dirección del puerto A */

void EXT_isr1() ;
void EXT_isr2() ;

ext_int_edge( L_TO_H );
port_b_pullups(TRUE);

#int_EXT
EXT_isr1()
{
//CODIGO DE LA INTERRUPCION RB0
delay_ms( 500 );             
bit_set( puerto_b, 1 );         
delay_ms( 500 );             
bit_clear( puerto_b, 1);
}

#int_RB
EXT_isr2()
{
//CODIGO DE LA INTERRUPCION RB4..RB7
delay_ms( 500 );             
bit_set( puerto_b, 2 );         
delay_ms( 500 );             
bit_clear( puerto_b, 2);
}

void main( void )
{
enable_interrupts(INT_EXT);   //INTERRUPCION POR CAMBIO EN RB0
enable_interrupts(INT_RB);   //INTERRUPCION POR CAMBIO EN RB
set_tris_b( 0x0f );            
set_tris_a( 0x00 );      
puerto_b = 0;                
puerto_a = 0;

while (TRUE)
   {        
     output_a(0xff);
          delay_ms(200);
        output_a(0x00);
          delay_ms(200);
    }
}


1) Que es lo que esta mal para que no se ejecuten las interrupciones ?
2) Por otro lado intente guardar el estado del puerto B en una variable
en main con "pepe=PUERTOB;"   y me da error .Como lo puedo hacer ?

[Lager.]

Que onda gustav03
1) Para que las interrupciones se habiliten te falta  enable_interrupts(GLOBAL) (intcon.7=1)
2) Solo tienes que definir tu variable podria ser con int pepe(8 bits) ya sea variable global o local, no te olvides que puerto_b(el que definiste en un principio) tambien es variable y puede ser tratada como tal.
Salu2 pana

[gustav03]

gracias amogo!

me pueden decir la diferencia entre estas dos
ext_int_edge(0, H_TO_L); que hace ese cero !!?
ext_int_edge( H_TO_L);
????

[Lager.]

No tienes nada que agradecer pana  para eso estamos
Las dos estan bien, la primera es mas que nada el formato completo para modelos de 16 bits(18fXXX), los cuales tienes 3 interrupciones externas(Rb0,Rb1 y Rb2) las tres con H to L y L to H, si pones cero es al portb0 si pones 1 es el portb.1,  y asi sucesivamente.
La forma completa de ponerlo es la primera, sea o no modelo de 16 bits, pero si no lo pones el defaul pone 0(para los modelos que solo tienen portb.0 de interrupcion), asi que por eso se descarta cuando son dispotitivos que solo contienen esa interrupcion.
Cuando es de H a L SOLO va a cambiar duando el pin pase de estado alto a bajo(de 0 a 1 logico) y la otra es lo inverso. Si por ejemplo esta de H to L y este pin no tiene habilitadas las pullups, hay que agregarle una resitencia de pullup(del pin a vcc) y el boton(para pruebas) del pin a GND.Si este pin (rb0)  esta tirado a tierra(switch cerrado) DESDE el arranque, cuando abramos el switch(pasara a estado logico alto) pero no entrara la interrupcion. solo cuando volvamos a cerrar dicho switch(a tierra) entonces si se cumplira de H(high) a L(low) y la interrupcion se llevara a cabo.

Salu2 pana

[gustav03]

gracias Lager !! pero si no te cansas de ayudarme, no me voy a cansar de darte las gracias .Ya le encontré la un poco la vuelta para no hacer preguntas que me puedo responder mirando la ayuda del  PCW .Recuerdo que me ayudaste con un problema en la sección de Proteus y me sugeriste que cambie al lenguaje c .Te cuento que sigo sin resolver el problema con las interrupciones del 16f84a .Soy un aficionado de estas cosas .En la facu me dieron un coco de c++ pero como te podrás imaginar en una carrera como ingeniería electromecánica no hay mucho tiempo para esas cosas .Tuve que aprender por mi mismo para profundizar en otros temas como electrónica y programación .Por suerte tengo la posibilidad de acceder a Internet y aprender de todos ustedes .Me gustaría ayudar pero no tengo mucho para ofrecer.
Aprovecho para preguntar otra ves con respecto al tema de las interrupciones .Resulta que implemente un ejemplo simple en ccs para prender tres led´s .Uno de esos leds se prende y se apaga conectado a en un bucle infinito en main ; otro que parpadea una ves cuando se produce una int. RB0 y un tercero que parpadea se la int. Es por RB . El problema es que entra en la rutina de RB y no sale nunca siendo las dos funciones RB0 y RB iguales excepto por el pin que activan .Sin mas palabras acá esta :
#include <16F84A.h>
#fuses XT,NOWDT
#use fast_io(A)
#use delay( clock = 4000000 )    /* reloj de 4 MHz */
#byte puerto_b = 06          /* dirección del puerto B */
#byte puerto_a = 05            /* dirección del puerto A */

 

#int_EXT
EXT_isr()
{
//CODIGO DE LA INTERRUPCION RB0
delay_ms( 500 );             
bit_set( puerto_a, 1 );         
delay_ms( 500 );             
bit_clear( puerto_a, 1);
}

#int_RB
EXT_isr2()
{
//CODIGO DE LA INTERRUPCION RB4..RB7
delay_ms( 200 );             
bit_set( puerto_a, 2 );         
delay_ms( 200 );             
bit_clear( puerto_a, 2);
}

void main( void )
{

enable_interrupts(GLOBAL);
enable_interrupts(INT_EXT);    
enable_interrupts(INT_RB);            
disable_interrupts(INT_RTCC);                        /*lo pongo para probar */
disable_interrupts(INT_TIMER0);                   /*lo pongo para probar */
ext_int_edge(H_TO_L);        
set_tris_b( 0xff );
set_tris_a( 0xf8 );        
puerto_b = 0;             
puerto_a = 0;

while (TRUE)
   {        
        delay_ms( 200 );             
        bit_set( puerto_a, 0 );         
        delay_ms( 200 );             
        bit_clear( puerto_a, 0);
    }
}

en el Proteus conecte el pin RB0 a una resistencia a v+ y un pulsador a masa lo mismo que en RB4 .

Cual puede ser el problema ?

[Lager.]

Pana Gustav03, no tienes nada que agradecer y con lo que puedas contribuir de ejemplos en este curso que lleva a cabo Modulay se te agradecera muchisimo y mas las personas que lo llevan a cabo.
Por otro lado, asi como esta tu codigo tiene un error, no has puesto el ; del bucle infinito. corrigiendo eso, debe de correr la interrupcion de B0, como es un switch este debe de lleva forzosamente un pullup o pull down(ya que no usas las pullups que trae por defaul el micro y te ahorrarian la resitencia extra en todo el puerto b)
Como especificaste en tu codigo va a cambiar SOLO de High to Low, es decir en estado estable(boton abierto) debe de tener un 1 logico para que SOLO cuando se oprima el boton(se cierre el circuito) este lo lleve a tierra(0 logico) y se lleve a cabo la interrupcion.... vasta de charla y solo tienes que poner un resistencia de 10k del pin b0 a vcc y del pin b0 a  a tierra atraves del boton.

TU CODIGOcon solo #INT_EXT )

#include <16F84A.h>
#fuses XT,NOWDT
#use fast_io(A)
#use delay( clock = 4000000 ) /* reloj de 4 MHz */
#byte puerto_b = 06 /* dirección del puerto B */
#byte puerto_a = 05 /* dirección del puerto A */

#int_EXT
EXT_isr()
{//CODIGO DE LA INTERRUPCION RB0
delay_ms( 500 );
bit_set( puerto_a, 1 );
delay_ms( 500 );
bit_clear( puerto_a, 1);
}


//#int_RB
//EXT_isr2()
//{//CODIGO DE LA INTERRUPCION RB4..RB7
//delay_ms( 200 );
//bit_set( puerto_a, 2 );
//delay_ms( 200 );
//bit_clear( puerto_a, 2);
//}
void main( void )
{set_tris_b( 0b11111111 ); /*Todas entradas!!*/
set_tris_a( 0b11111000 );  /*a0-a2 salidas*/
puerto_b = 0;
puerto_a = 0;
enable_interrupts(INT_EXT);
//enable_interrupts(INT_RB);
//ext_int_edge(H_TO_L);
enable_interrupts(GLOBAL);
disable_interrupts(INT_RTCC); /*lo pongo para probar */
disable_interrupts(INT_TIMER0); /*lo pongo para probar */


while (TRUE)
{delay_ms( 200 );
bit_set( puerto_a, 0 );   /*a0=1*/
delay_ms( 200 );
bit_clear( puerto_a, 0);  /*a0=0*!*/
};              /*;<-------lo que faltaba*/            
}

[gustav03]

Gracias Lager !!!
lo voy a hacer como secis y despues te consulto o te doy las gracias definitivas

[gustav03]

Bueno ya le meti el ";" incluso me mandaron una vercion mas actializada de ccs y no anda !
el programa sale sin errores pero tira el mensale siguiente:
>>> Warning 216 "C:PICCCSledparp_led.c" Line 52(0,1): Interrupts disabled during call to prevent re-entrancy:  @delay_ms1

lo simulé en Proteus y cuando presiono el pulsador que activa la interrupcion RB esta fincion se ejecuta de totma continua .Es decir entra en main -> presiono el boton -> entra en la int RB la ejecuta -> vuelve a main e inmediatamente entra en la fincion de INT RB !
Que estoy haciendo mal ?
ccs v3.2
MPLAB v6.3
Proteus v6.3

NOTA : me refiero al ejemplo anterior  .Solo que le cambie la interrupcion que quiero que se active por RB porque con la INT RB0 no tengo problemas ahora en este ejemplo .

[Lager.]

Que onda pana,
Tienes toda la razon y es por que en el post anterior me equivoque y te puse que este era para RB0, y para nada, el que es para RB0 es el int_ext y para cualquier cambio en los pines (rb4,rb5,rb6,rb7) se usa el int Rb.
Nuevamente una disculpa pana, me revolvi pesimamente.
El codigo te quedaria asi:

#include <16F84A.h>
#fuses XT,NOWDT
#use fast_io(A)
#use delay( clock = 4000000 ) /* reloj de 4 MHz */
#byte puerto_b = 06 /* dirección del puerto B */
#byte puerto_a = 05 /* dirección del puerto A */

//#int_EXT
//EXT_isr()
//{//CODIGO DE LA INTERRUPCION RB0
//delay_ms( 500 );
//bit_set( puerto_a, 1 );
//delay_ms( 500 );
//bit_clear( puerto_a, 1);
//}

#int_RB
EXT_isr2()
{//CODIGO DE LA INTERRUPCION RB4..RB7
delay_ms( 150 );
bit_set( puerto_a, 2 );
delay_ms( 150 );
bit_clear( puerto_a, 2);
}
void main( void )
{set_tris_b( 0b11111111 ); /*Todas entradas!!*/
set_tris_a( 0b11111000 );  /*a0-a2 salidas*/
puerto_b = 0;
puerto_a = 0;
//enable_interrupts(INT_EXT);
//ext_int_edge(4,H_TO_L);
enable_interrupts(INT_RB);
enable_interrupts(GLOBAL);
//disable_interrupts(INT_RTCC); /*lo pongo para probar */
//disable_interrupts(INT_TIMER0); /*lo pongo para probar */


while (TRUE)
{delay_ms( 200 );
bit_set( puerto_a, 0 );   /*a0=1*/
delay_ms( 200 );
bit_clear( puerto_a, 0);  /*a0=0*!*/
}            
}

Si esta entrando y no  deja de entra al bucle de interrupcion
Un abrazo

[Lager.]

Que onda pana,
Tienes toda la razon y es por que en el post anterior me equivoque y te puse que este era para RB0, y para nada, el que es para RB0 es el int_ext y para cualquier cambio en los pines (rb4,rb5,rb6,rb7) se usa el int Rb.
Nuevamente una disculpa pana, me revolvi pesimamente.
El codigo te quedaria asi:

#include <16F84A.h>
#fuses XT,NOWDT
#use fast_io(A)
#use delay( clock = 4000000 ) /* reloj de 4 MHz */
#byte puerto_b = 06 /* dirección del puerto B */
#byte puerto_a = 05 /* dirección del puerto A */

//#int_EXT
//EXT_isr()
//{//CODIGO DE LA INTERRUPCION RB0
//delay_ms( 500 );
//bit_set( puerto_a, 1 );
//delay_ms( 500 );
//bit_clear( puerto_a, 1);
//}

#int_RB
EXT_isr2()
{//CODIGO DE LA INTERRUPCION RB4..RB7
delay_ms( 150 );
bit_set( puerto_a, 2 );
delay_ms( 150 );
bit_clear( puerto_a, 2);
}
void main( void )
{set_tris_b( 0b11111111 ); /*Todas entradas!!*/
set_tris_a( 0b11111000 );  /*a0-a2 salidas*/
puerto_b = 0;
puerto_a = 0;
//enable_interrupts(INT_EXT);
//ext_int_edge(4,H_TO_L);
enable_interrupts(INT_RB);
enable_interrupts(GLOBAL);
//disable_interrupts(INT_RTCC); /*lo pongo para probar */
//disable_interrupts(INT_TIMER0); /*lo pongo para probar */


while (TRUE)
{delay_ms( 200 );
bit_set( puerto_a, 0 );   /*a0=1*/
delay_ms( 200 );
bit_clear( puerto_a, 0);  /*a0=0*!*/
}            
}

Si esta entrando y no  deja de entra al bucle de interrupcion ponle un disable_interrupts(global); , si esto no te deshabilita la interrupcion y sigue haciendo lo mismo, haslo de forma asm LIMPIANDO el flag y deshabilitando la interrupcion global, si AUN sigue el problema... ES MUY  PROBABLE que proteus este mal, pruebalo en armado normal(sin nada de lo que te comente.. ) y ya vemos.
Un abrazo

[Lager.]

Aqui esta funcionando pana:

#include <16F84A.h>
#fuses XT,NOWDT
#use fast_io(A)
#use delay( clock = 4000000 ) /* reloj de 4 MHz */
#byte puerto_b = 06 /* dirección del puerto B */
#byte puerto_a = 05 /* dirección del puerto A */
#byte intcon=0x0b    /*Regisro de interrupcion*/
#bit RBIE=intcon.3    /*Para  limpiar flag de interrupcion!!!*/

//#int_EXT
//EXT_isr()
//{//CODIGO DE LA INTERRUPCION RB0
//delay_ms( 500 );
//bit_set( puerto_a, 1 );
//delay_ms( 500 );
//bit_clear( puerto_a, 1);
//}

#int_RB
void x(){
delay_ms( 350 );
bit_set( puerto_a, 1 );
delay_ms( 350 );
bit_clear( puerto_a, 1);
delay_ms(100);
RBIF=0;  /*hacemos lo que no hace c,limpiar el flag!!*/
}
 main()
{set_tris_b( 0b11111111 ); /*Todas entradas!!*/
set_tris_a( 0b11111000 );  /*a0-a2 salidas*/
puerto_b = 0;
puerto_a = 0;
//enable_interrupts(INT_EXT);
//ext_int_edge(4,H_TO_L);
enable_interrupts(INT_RB);
enable_interrupts(GLOBAL);
//disable_interrupts(INT_RTCC); /*lo pongo para probar */
//disable_interrupts(INT_TIMER0); /*lo pongo para probar */

while (1)
{delay_ms( 200 );
bit_set( puerto_a, 0 );   /*a0=1*/
delay_ms( 200 );
bit_clear( puerto_a, 0);  /*a0=0*!*/
}
}

Aun asi, lo mas seguro es que sea error de proteus, ya que en el la linea 27 del codigo(}) se sallta la direccion 0056 donde esta el  BCF  INTCON,RBIF que es justo la instruccion que limpia el flag de cambio............. Deberias de probarlo como lo tenias pero armado ,ya que como ves si esta borrando la bandera de interrupcion,mas no la esta leyendo.
Otra observacion:
Si pones la interupcion asi:
#int_RB //NOCLEAR
void x(){
delay_ms( 350 );
bit_set( puerto_a, 1 );
delay_ms( 350 );
bit_clear( puerto_a, 1);}  //RBIE=0;
Ahora se salta el BCF 5,1 es decir el apagado del led!!!, jajajajajaja, es 99% probable que sea proteus, pero eso solo lo sabremos cuando lo pruebes armandolo.

CONFIRMADO:
PESIMO el proteus con en estas interrupciones(Rb4:RB5:RB6:RB7),.... he probado el codigo sin las modificaciones anteriormente hechas...(como estaba desde un principio), trabaja PERFECTO en montaje real, polarizando(con resitencias externas) positiva o negativamente los pines (RB4,RB5,RB6, y RB7) y con AMBOS cambios(hacia tierra o hacia vcc), lo unico que debes de tener en cuenta(por que si no a veces  por ruido externo o demas) es de poner en el estado seleccionado como reposo(antes del cambio en esos pines) los 4 pines.. para que no  se quede la ISR clavada.... pero de ahi en fuera probe con proteus 6.5 sp5, y SOLO FUNCIONA DE UNA FORMA(con resistencias a GND y cambio de estado con vcc) y lo hace de todas formas incorrectamente, ya que se queda en la interrupcion. De la forma de cambio de estado a GND de plano se queda en la interupcion o no sucede..... Asi que ya sabes pana, FUNCIONA PERFECTAMENTE TU CODIGO.

Salu2

[gustav03]

bueno ya encontre el problema jajajajaja no me lo vas a creer se solucionó colocando un :
while(!input(pin_B4)&!input(pin_B5)&!input(pin_B6))
{};
en la fincion de la interrupcion .El problema es que Proteus simula como si al apretar una tecla o boton se generaran rebotes.No me lo imagine se me ocurrio prestando atencion a la forma que Proteus actualiza las imagenes (resulta que el codigo corre a mil por hora pero las imagenes a paso de tortuga  jajaja ).
en cuanto a que el c no actualiza los flag de interrupcion al salir de la int. si que lo hace solo que al simularlo como le hicimos se producian muchos rebotes y el tiempo en que salia de la funcion de interrupcion fué muy corto.

Bueno creo que tengo las cosas claras gracias a vos
Bueno todo claro menos algo jajaja .Porque no puedo tener INT_RB0 y INT_RB al mismo tiempo si al producirse una de las dos queda anulada la otra automaticamente ?

[Lager.]

Escrito originalmente por Lager.Aqui esta funcionando pana:

#include <16F84A.h>
#fuses XT,NOWDT
#use fast_io(A)
#use delay( clock = 4000000 ) /* reloj de 4 MHz */
#byte puerto_b = 06 /* dirección del puerto B */
#byte puerto_a = 05 /* dirección del puerto A */
#byte intcon=0x0b    /*Regisro de interrupcion*/
#bit RBIE=intcon.3    /*Para  limpiar flag de interrupcion!!!*/

//#int_EXT
//EXT_isr()
//{//CODIGO DE LA INTERRUPCION RB0
//delay_ms( 500 );
//bit_set( puerto_a, 1 );
//delay_ms( 500 );
//bit_clear( puerto_a, 1);
//}

#int_RB
void x(){
delay_ms( 350 );
bit_set( puerto_a, 1 );
delay_ms( 350 );
bit_clear( puerto_a, 1);
delay_ms(100);
RBIF=0;  /*hacemos lo que no hace c,limpiar el flag!!*/
}
 main()
{set_tris_b( 0b11111111 ); /*Todas entradas!!*/
set_tris_a( 0b11111000 );  /*a0-a2 salidas*/
puerto_b = 0;
puerto_a = 0;
//enable_interrupts(INT_EXT);
//ext_int_edge(4,H_TO_L);
enable_interrupts(INT_RB);
enable_interrupts(GLOBAL);
//disable_interrupts(INT_RTCC); /*lo pongo para probar */
//disable_interrupts(INT_TIMER0); /*lo pongo para probar */

while (1)
{delay_ms( 200 );
bit_set( puerto_a, 0 );   /*a0=1*/
delay_ms( 200 );
bit_clear( puerto_a, 0);  /*a0=0*!*/
}
}

Aun asi, lo mas seguro es que sea error de proteus, ya que en el la linea 27 del codigo(}) se sallta la direccion 0056 donde esta el  BCF  INTCON,RBIF que es justo la instruccion que limpia el flag de cambio............. Deberias de probarlo como lo tenias pero armado ,ya que como ves si esta borrando la bandera de interrupcion,mas no la esta leyendo.
Otra observacion:
Si pones la interupcion asi:
#int_RB //NOCLEAR
void x(){
delay_ms( 350 );
bit_set( puerto_a, 1 );
delay_ms( 350 );
bit_clear( puerto_a, 1);}  //RBIE=0;
Ahora se salta el BCF 5,1 es decir el apagado del led!!!, jajajajajaja, es 99% probable que sea proteus, pero eso solo lo sabremos cuando lo pruebes armandolo.

CONFIRMADO:
PESIMO el proteus con en estas interrupciones(Rb4:RB5:RB6:RB7),.... he probado el codigo sin las modificaciones anteriormente hechas...(como estaba desde un principio), trabaja PERFECTO en montaje real, polarizando(con resitencias externas) positiva o negativamente los pines (RB4,RB5,RB6, y RB7) y con AMBOS cambios(hacia tierra o hacia vcc), lo unico que debes de tener en cuenta(por que si no a veces  por ruido externo o demas) es de poner en el estado seleccionado como reposo(antes del cambio en esos pines) los 4 pines.. para que no  se quede la ISR clavada.... pero de ahi en fuera probe con proteus 6.5 sp5, y SOLO FUNCIONA DE UNA FORMA(con resistencias a GND y cambio de estado con vcc) y lo hace de todas formas incorrectamente, ya que se queda en la interrupcion. De la forma de cambio de estado a GND de plano se queda en la interupcion o no sucede..... Asi que ya sabes pana, FUNCIONA PERFECTAMENTE TU CODIGO.

Salu2

Que bueno que lo hayas podido simular pana, pero no es el punto adaptar un codigo 100% FUNCIONAL(tu codigo sin cambios) a la forma que proteus le guste mas correrlo adecuadamente. Como te comente, tu codigo funciona con  AMBAS interrupciones(int_ext y int_rb) al mismo tiempo y al 100%, ese cambio adicional(el que implementaste) no es necesario. Y si pana , claro que puedes usar dos o mas interrupciones...... (tambien esta por ahi el #priority .... para prioridades en interrupciones de alta a baja)

Salu2

[gustav03]

OK gracias !!