#if defined(__PCM__)
#include <16f877.h>
#FUSES NOWDT, XT, PUT, NOPROTECT, BROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG
//#fuses
#use delay(clock=4M)
#DEFINE use_portd_lcd TRUE
#include <lcd.c>
#include <stdio.h>
#use standard_io(A)
#BYTE PORTB=0x06
#BYTE TRISB=0X1f //0001 1111
#BYTE PORTD=0X08
#BYTE TRISD=0X88 //1000 1000
#INT_RB //CAMBIO DE ESTADO ENTRE RB4 - B7
//Error si pongo aqui void RB_isr() //función de interrupción*
int1 grp2,grp3;
int1 ladra[5];
int8 peti,cliente,salir,nume;
int1 tarje,ser,nu;
unsigned int8 lee,atra,falloMF;
signed int32 mony;
int1 target[20];
int16 contra[20];
signed int32 saldo[20];
signed int32 M32;
union UNI {
signed int32 dat32;
int8 bytes[4];
};
signed int32 total,acumula;
int32 presta;
int16 meses=10;
int8 decimal,vari;
float prestamo,teres=2;
void lectura();
void borratotal();
void ponsea();
void ponme();
void skri();
void recogmateria();
void reembolso(int8 cli);
void refresco(int1 muta,int1 gp1,int1 gp2,int1 gp3);
int1 MASTER;
void recoge();
void COMBERSION(int1 Soy);
void tiempo(int8 espe);//
void mensaje(int8 men);
void mensa(int8 me);
void sajesal(int1 acet,int1 line);
void OPER(int8 dar);
void acionSalida();
void evalua();
//Error si pongo aqui #INT_RB*
void RB_isr() //función de interrupción
{
unsigned int8 valor=input_B();
valor=valor&0b00010000;
lcd_gotoxy(1,1);
if (valor>0){
output_high(PIN_a0);
lcd_putc("dentro");
}
else {
lcd_putc("no es b4"); }
delay_ms(1000);
output_low(PIN_a0);
clear_interrupt(INT_RB);
}
void main(){
int8 con,nume;
ext_int_edge(l_to_h);//alto
clear_interrupt(INT_RB);
enable_interrupts(int_RB);
enable_interrupts(global);
set_tris_b(0b00011111);
while(true){///WIL main()
.......
.......
} }
#int_RB
void RB_isr() //función de interrupción
{
unsigned int8 valor=input_B();
valor=valor&0b00010000;
lcd_gotoxy(1,1);
if (valor>0){
output_high(PIN_a0);
lcd_putc("dentro");
}
else {
lcd_putc("no es b4"); }
delay_ms(1000);
output_low(PIN_a0);
clear_interrupt(INT_RB);
}Solo se que RTOS esta vinculado a las interrupciones me meti aqui por esto pero todas las preguntas en las que me meti sobre #INT_RB No ablaban de ello Ni e visto seccion particular a ello que es lo que queria
El codigo tiene la ron del micro quemada y no queria liaros con el pero la interrupcion en si es muy corta no esta esigiendo nada en si (si es malo que sea larga malo malo porque eso es lo que deberia ser) y necesito que se ejecute de manera instantanea teniendo prioridad a cualquier otra cosa que este haciendo el programa
Segun yo cuando B4-7 pase a true se interrumipira cualquier cosa que este haciendo el programa para ejecutar void RB_isr() esta es una funcion como otra cualquiera solo que se ejecuta si hay señal entre b4-b7 no porque el programa en si la llame en un determinado momento ¿este concepto es "true o false"?
//////////////////RECOGE //lee lo que le pida micro2 master
void recoge(){
output_low(PIN_C6);///S.envio 0 = pic2_B7_MASTER/E.envio
output_high(PIN_C1);//RS TRUE
int8 co;
int1 muta=0;
//while (Input(PIN_C0)==0) { }
//while(!spi_data_is_in()){ }
//AMBOS While son de los que me queria librar cuando micro es slave pierde todo el tiempo encerrado aqui y tiende a dar error
//sin hacer nada ahora ya es tarde no se me ocurre que puede hacer micro mientras sea slave*
output_high(PIN_C1);//RS TRUE
grp2=spi_read();
protSlave();
grp3=spi_read();
protSlave();
if (grp2==1) {////**per 2 (estado-salidas pic1)
for (co=0;5>co;co++){
ladra[co]=spi_read();
protSlave();
}
}////**per 2
if (grp3==1) {////**per 3
peti=spi_read();// int8 peti
protSlave();
salir=spi_read();// salir
protSlave();
cliente=spi_read();// cliente
protSlave();
target[cliente]=spi_read();// int1 targe[ ]
protSlave();
tarje=spi_read();// int1 tarje
protSlave();
union UNI M32;//int32 mony
for(co=0;co<4;co++){
M32.bytes[co] = spi_read();
protSlave(); }
mony=M32.dat32;
}////**per 3
muta=spi_read();// *cliente
output_high(PIN_C6);//S.envio=true -----> pic2_b7_MASTER/E.envio
if (grp2==1) {
if (ladra[0]) { output_high(PIN_a0); } else { output_low(PIN_a0); } delay_ms(1); //delay_ms(2);
if (ladra[1]) { output_high(PIN_a1); } else { output_low(PIN_a1); } delay_ms(1);
if (ladra[2]) { output_high(PIN_a2); } else { output_low(PIN_a2); } delay_ms(1);
if (ladra[3]) { output_high(PIN_a3); } else { output_low(PIN_a3); } delay_ms(1);
if (ladra[4]) { output_low(PIN_a4); } else { output_high(PIN_a4); } delay_ms(1);//neg
} else {
delay_ms(5); }
delay_ms(2);
output_low(PIN_C6);
output_low(PIN_C1);//RS FIN
if (muta) { COMBERSION(1); delay_ms(16); }
}
///////////////REFRESCO///////////////REFRESCO///////////////REFRESCO///////////////REFRESCO///////////////REFRESCO
void refresco(int1 muta,int1 gp1,int1 gp2,int1 gp3){//,int1 gp4){//,int1 gp5){
int8 co;
falloMF=0;
output_low(PIN_c6);//S.envio incial 0
output_high(PIN_C2);//RW TRUE
spi_write(gp1);/////ESTO es una perdida de tiempo si se kieren comunicar todos los datos........
///////output_high(PIN_c6);
//delay_ms(2);//TIEMPO
protMaster();
spi_write(gp2);
protMaster();
spi_write(gp3);///gp3 acava realmente escrita en gp[2] de savle
protMaster();
if (gp1==1) {//**per PERO si gp1==false se ahorra tiempo master y sable sabran que no es necesario comunicarse los datos del "grupo 1"
for (co=0;5>co;co++){
spi_write(ladra[co]);//int1
protMaster();
}
}//**per 3
if (gp2==1) {//**per 3
spi_write(salir); /// int8 salir
protMaster();
spi_write(tarje); /// int1 tarje
protMaster();
union UNI M32;//int32 mony
M32.dat32 =mony;
for(co=0;co<4;co++) {
spi_write(M32.bytes[co]);
protMaster(); }
}//**per 3
if (gp3==1) {//**per 3
spi_write(nume);//int8
protMaster();
spi_write(target[nume]);//int1
protMaster();
}//**per 3
spi_write(peti); /// int8 peti
protMaster();
spi_write(muta);//
protMaster();
output_low(PIN_c2);//RW FIN
if (muta) { COMBERSION(0); } else { delay_ms(20); }
}
Lo que no es correcto es el funcionamiento de la interrupcion. Esa interrupcion actua ante el cambio. Es decir, si pasa de 1 a 0 , o de 0 a 1 cualquier entrada de las RB4 a RB7. Asi que tenes que tener en cuenta que cuando la entrada pasa de 1 a 0, tambien entraria en la interrupcion y no solamente cuando pasan a 1.
nuevamente tu interrupcion debe durar poco.
una buena opción es el PIC18F452.Si es por la memoria Tiene buena pinta me coinciden todos los pin pero quizas tenga que mirar de que va FAST_IO Todo el proyecto esta creado para tratar con pic16 por lo demas me estoy biendo bien con una sola interrupcion por esto la e cambiado por #INT_EXT esto apenas me a esigido modificar nada Lo que me a creado cierta confusion al adentrarme en el programa esta tarde es que lo que era antes la funcion recoge() Esta no esta de una manera visible en el codigo y se cumple de manera fantasmal si no tienes cuidado