Ejemplitos en C para 16F648A

[vszener]

La verdad es que no tendria por que entrar en la interrupcion, haber si en algunos de los pines del potB aparece un '1' logico el cual ejecuta la interrupcion.....de todas formas podrias poner el esquema del circuito, como veo que te basas en el ejemplito de las interrupciones del portb, veras que la instruccion de poner alto y en bajo el pin B0 es simplemente para indicar qie estamos en la interrupcion, asi que no infuye en la misma...


Suerte!!!

[jfh900]

Es normal que sea necesaria esa instrucción. Me explico: cuando trabajamos con interrupciones por nivel, necesitamos conocer el nivel anterior para comparale con la entrada actual y determinar si hay un cambio de nivel, esto se consigue mediante unos lanch. Cuando hay un cambio de nivel, se activa la interrupción y tenemos un valor distinto en el lanch que en la patilla correspondiente (por eso a saltado la interrupcion, por el cambio de nivel), el CCS no se preocupa de actualizar el lanch con lo cual si salimos de la interrupcion sin refrescar los lanch seguimos con distintos niveles en la patilla y en el lanch y se vueleve a disparar la interrupción. Como se refrescan los lanch, pues simplemente leyendo en los puertos correspondientes que estemos utilizando. Por eso es necesario poner:

input(PIN_B0);

Para  que se actualicen los lanch. En el main se deberia realizar una lectura antes de activar las interrupciones para actualizar los lanch. yo uso el siguiente código:

Código: CSS

1. #asm movf PORTB,0 #endasm

Un saludo.

[vszener]

Me parece que el amgino no habla de la interrupcion externa del pin B0, sino la interrupcion del puerto B de los pines 4 al 7, que en caso de algun cambio en ellos pues ocurre una interrupcion.


Suerte!!!

[jfh900]

Da igual sobre que pin se actue en la lectura, cuando se realiza un ciclo de lectura se refrescan todos los latch.

Un saludo.

[vszener]

No es por marear la periz pero, ¿que tiene que ver la interrupcion del puerto b de los pines 4 al 7 con el refresco del pin b0 del puerto b? son cosas independientes, como bien has puesto en la foto, te indica que dicho refresco son sobre los pines 4 al 7, los mismos de la interrupcion, pero no del pin B0...


Suerte!!!

[jfh900]

Efectivamente no mareemos la perdiz. Si te has fijado, la señal que realiza el refresco es RD Port, osease lectura del puerto, siempre que se lee un pin del puerto se activa esta señal independiente del que se lea. Por otra parte si crees que no funciona con el bit B0, pues se cambia a B4 y ya esta, aunque estas discursiones no tienen sentido, se prueba y listo. Yo lo he probado y funciona, ya que me pasaba lo mismo que a Simulpic y lo solucione así y por otra parte me puedes explicar por que cuando quita la linea output_low(PIN_B0);  deja de funcionar (que curioso el PIN_BO), yo he dado la explicación y lo he documentado con el esquema, puedes tu explicarlo de otra forma?.

Un saludo.

[vszener]

Bueno sin entrar en polemicas, simplemente a favor de la ciencia para llegar a la verdad absoluta (jeje).....por partes:

1. La señal de refresco efectivamente es la lectura del puerto, eso si, si te fijas tambien es la lectura del puerto para los pines de la interrupcion, concretamente los pines B4, B5, B6 y B7. Se, ya que eres asiduo al foro, de que sabes de estos 'cacharros' bastante, pero no se si se te ha pasado o simplemente no te has dado cuenta, de que los pic's poseen una interrupcion la cual consiste en generar una interrupcion al cambio de estado de cualquier pin comprendido entre el 4 y el 7 del puerto b, esta interrupcion es la llamada interrupcion del puerto b, la cual es independiente de la interrupcion externa(la cual consiste en generar una interrupcion por el pin B0 del puerto b).

2. Con respecto a si creo que no funciona con el pin B0 y que lo cambie al pin B4, pues no es que no lo crea, es que simplemente estas hablando de cosas diferentes, como bien dice el apartado 1. , la interrupcion externa(producida por el cambio de estado del pin B0) es independiente a la interrupcion del puerto b(generada por los pines del 4 al 7 del puerto b), por lo tanto no vale como respuesta el cambiar de pines ya que no estariamos hablando de la misma interrupcion.

3. Estoy contigo de que la mejor manera es probarlo, por eso mismo el amigo Simulpic ha preguntado esa duda o ese problema que tiene él, porque se ha basado en uno de los ejemplos que esta en este post, concretamente es el ejemplo numero 48 que lo realize el dia 15/Noviembre/05, y dicho ejemplo consiste en utilizar la interrupcion del puertob comprendida por los pines 4 al 7, y es mas, dicho ejemplo consiste en mostrar como saber que pin de dicha interrupcion produce la propia interrupcion. Por lo tanto, yo no hablo sin probar las cosas, es mas el programa lo realice yo.

4. Con respecto a la instruccion output_low(PIN_B0);, ¿para que esta? ¿por que se puso en el ejemplo numero 48 que trata de la interrupcion del puerto b? pues sencillamente, nos podriamos ir al ejemplo numero 48(el cual esta en la pagina 12 de este mensaje) y veriamos que alli donde esta escrito yo comento parte del funcionamiento del programa, y en ese parrafo donde comento parte del funcionamiento del programa digo lo siguiente:

Código: [Seleccionar]

Buenas!!!!bien, el programa de hoy se basa en las interrupciones producidas al cambio de estado por uno de los pines del portb dedicados a dicha tarea, los pines que generan interrupcion son <4:7>. El programa en si realiza la secuencia de luces del coche fantastico con 4 led"s hasta que uno de los pines <4:7> cambia de estado del port b, entonces genera una interrupcion y realiza una secuencia de iluminacion de los led"s distinta, [color=red]aparte cada vez que estemos en una interrupcion se iluminara el led conectado al pin b0[/color]....bueno aqui el codigo!:
Por lo tanto que el pin B0 entre en juego en este programa es simplemente para mostrar al que lo simula o lo monte, que cuando cambie algun estado de los pines 4 al 7 del puerto b, se iluminara el pin B0 para decir al usuario que estamos dentro de la interrupcion y en el momento de haber realizada dicha interrupcion se apagara dicho pin B0 para decir al usuario que ya no estamos en la interrupcion, sino en el programa principal. Por eso mismo la instruccion output_low(PIN_B0);  aparece en el programa porque al entrar en la interrupcion esta la instruccion output_high(PIN_B0);. Y no esta para nada mas que para eso, para indicar que estamos dentro o fuera de la interrupcion.

5. Con respecto a la documentacion y al esquema me parecen fabuloso que lo hagas, pero veras que el esquema trata de los pines 4 al 7, indicas en dicho esquema que para el refresco se usa la lectura del puerto b entero, claro que si, pero si te vas al data sheet del 16F648A concretamente en la pagina 38(para el adobe, la pagina 36 para el data sheet) te dice que la lectura del puerto b se realiza para compararla con el estado d elo spines 4 al 7 del puerto b para ver si alguno de ellos cambia su estado y asi producir la interrupcion, pero no vale para nada mas, y en este caso el pin b0 no interviene sino simplemente los pines b4, b5, b6 y b7.

6. Para seguir documentando la explicacion y el ejemplo, el programa numero 48 como bien he mencionado ya, se basa en la interrupcion del puerto b(los cuales intervienen los pines del 4 al 7 del mismo puerto), y se basa tambien en decir al usuario que pin genero dicha interrupcion(no nos olvidemos que los pines que pueden generar la interrupcion son los pines b4,b5,b6 y b7), dicho ejemplo, como bien comento cuando lo escribi, esta en parte, sacado de la ayuda del compilador CCS, concretamente si te vas a la help del CCS, en la pagina 267(para el adobe, 255 para el compilador) veras que te dan un trozo de codigo para indicar que pin de la interrupcion del puerto b genera dicha interrupcion(recordar por n-esima vez que los pines para la interrupcion son simplemente los comprendidos entre el pin 4 y el 7) y veras que dicho codigo no interviene para nada el pin B0 pero si se usa la lectura del puerto b entero pero para manejarlo simplemente para los pines b4, b5, b6 y b7(esto es asi, ya que resulta mas facil leer el puerto entero que pin a pin), y veras en dicho trozo de codigo que esta en el manual del compilador que la instruccion output_low(b0); no aparece por ningun lado, claro esto es asi ya que esa instruccion la puse yo en el programa mio para indicar, como ya he mencionado, cuando estamos dentro de la interrupcion.

7. Imaginate que para generar la interrupcion sea de flanco de subida a flanco de bajada del pin, la instruccion output_low(b0); siempre generaria una interrupcion segun tu explicacion, por lo tanto algo esta mal....

En resumen, me parece que te has confundido de interrupcion, no es la interrupcion externa que si maneja en pin b0, en este caso estamos tratando la interrupcion del puerto b que maneja los pines b4, b5, b6 y b7, por lo tanto el pin b0 no interviene, ya que en el caso de intervenir tendriamos una interrupcion menos, imaginate que tenemos un programa que usa tanto la interrupcion externa(es decir el cambio de estado del pin b0) como la interrupcion del puerto b(es decir, el cambio de estado de los pines 4 al 7) y ademas, que el pin b0 este configurado para generar una interrupcion cuando cambie de '1' a '0' logico, segun tu explicacion al poner output_low(b0); al termino de la interrupcion del puerto b(los pines del 4 al 7 del puerto b) generaria segun el punto 7 de mi explicacion una interrupcion externa, ¿pero seria externa o de software? seria de software, por lo tanto esta mal tu explicacion.

Al amigo Simulpic, no le funcionara bien porque al simularlo, seguro que algun pin del puerto b(pines comprendidos unicamente del 4 al 7 ambos inclusive) cambiaran de estado, produciendole una interrupcion.

Y no quiero con esto entrar en polemicas contigo, amigo jfh900, sino dar mi explicacion de como creo que es.


Suerte!!!

[jfh900]

Por supuesto que no estamos entrando en polémicas, solo estamos dando nuestra opinion sobre una cuestion planteada y esto lejos de ser malo es todo lo contrario.

Volviendo al tema, estamos hablando de cosas diferentes.

Yo lo que digo es que como se compara el valor actual del pin b4/b7 con los valores de los lantch que han guardado el estado anterior, si se produce un cambio de nivel y se dispara la interrupción, hay que refrescar los lantch para que guarden el nuevo estado de los pines de entrada, y esto hay que hacerlo antes de salir de la interrupción, si no sigue habiendo un cambio de nivel y se vuelve a producir la interrupción. Como se logra refrescar los lantch mediante una lectura del puerto b, da lo mismo leer todo el puerto que un solo pin, por eso como las interrupciones se estaban produciendo en los pines b4/b7 yo leia el pin b0 que por ser del puerto.

Y como veo que has echo los deberes y te has leido el datasheet yo te pongo lo que dice el datasheet al respecto:

This interrupt can wake the device from SLEEP. The
user, in the Interrupt Service Routine, can clear the
interrupt in the following manner:
a) Any read or write of PORTB. This will end the
mismatch condition.
b) Clear flag bit RBIF.
A mismatch condition will continue to set flag bit RBIF.
Reading PORTB will end the mismatch condition and
allow flag bit RBIF to be cleared.

Donde especifica claramente como borrar la interrupcion. El problema es que el CCS solo borra el flas RBIF antes de salir de la interrupción y no actualiza los lantch, con lo que se produce un bucle infinito en la interrupción.

Un saludo.

[vszener]

Bueno parece que ya vamos centrando el problema cada vez mas jeje, supongo que ya tenemos claro que la instruccion output_low(pin_b0); no interviene para nada en la interrupcion del puerto b(pines del 4 al 7), como bien has puesto, para terminar la interrupcion del puerto b <4:7> debemos realizar las operaciones:

a) Leer o escribir en el puerto b, y asi se eliminara la condicion de error. Quizas por eso el escribir en el pin B0 hacia que no se volviera a la interrupcion(aunque a nivel de programacion usar dicha instruccion para tal fin es un error).

b) Limpiar el bit indicado de la interrupcion RBIF

Aparte apunta y aclara el manual que en caso de condiciones de error, hagamos una lectura del puerto b para que el bit indicador de la interrupcion vuelva a su estado normal.

Bien, con estos datos en la mano vamos al lio:

1. El programador no debe realizar estas instrucciones cuando esta trabajando en lenguaje de medio/alto nivel, ya que es el compilador el que lo hace o debe hacer por uno mismo, indicas que el compilador CCS simplemente limpia el bit de la interrupcion RBIF, la verdad que no lo se, es cuestion de mirar el archivo .list que genera para ver su codigo asm, en cuanto este en mi ordenador con mis archivos lo vere y lo probare, pero volver a recalcar que poner la instruccion output_low(pin_b0); en caso de que el compilador tenga un fallo de fin d ela interrupcion es un error.

Bien, llegando a este punto aclarar y volver a recalcar que la instruccion o el manejo del pin b0 no interviene en la interrupcion del puerto b <4:7>, en caso de que el compilador no tenga en cuenta el punto a) que indicas y simplemente tenga en cuneta el punto b), pues tendra problemas cuando surgan condiciones anomalas como bien indica el data sheet del dispositivo, por lo tanto estamos ante un fallo del compilador....a la espera de confirmar esto para la semana que viene que estare en mi ordenador con mis archivos, corto y cambio.


Suerte!!!

[jfh900]

Efectivamente ya se va centrando el tema, pero debo de aclarar que yo en ningun caso he dicho que para refrescar los lantch haya que poner output_low(pin_b0); eso estaba en un programa que Simulpic posteo y que no entendia para que servia. Yo lo que puse fue utilizar: #asm movf PORTB,0 #endasm que lo que hace es leer el puerto B y como hemos visto refrescar los lantch. Por que he hecho de esta forma?: en primer lugar como es una instrucción que hay que poner dentro del tratamiento de la interrupción, debe de ser lo mas corta ya rapida posible, por eso la pongo en ASM para que el compilador no ponga su tratamiento de entradas y salidas. Como ves lo que hago es leer el puerto b mediante la lectura del pin B0, ¿por qué el B0? pues por que es el primero numéricamente y como da igual leer uno que otro he seleccionado este. Un programa de prueba podria ser:

#include <16F84.h>
#fuses NOWDT,RC, NOPUT, NOPROTECT
#use delay(clock=4000000)

int nInd;
BOOLEAN lInterrupt;

#int_RB
RB_isr()
{
  nInd++;
  lInterrupt = TRUE;
 #asm movf PORTB,0 #endasm
}

void main() {

  nInd = 0;
  lInterrupt = FALSE;

  set_tris_a(0x0);     // Todo salidas
  set_tris_b(0xFF);    // Todo entradas
  output_a(0xFF);

  setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
  enable_interrupts(INT_RB);
  enable_interrupts(GLOBAL);

  while(true)
     {
     if (lInterrupt==TRUE)
        {
        output_a(nInd);
        lInterrupt = FALSE;
        }
     }
}

Podras ver todo lo comentado, si comentas y descomentas la línea: #asm movf PORTB,0 #endasm
y realizas una simulación en Proteus.

Un saludo.

[vszener]

Buenas!!! lo prometido es deuda!!! como bien dice el amigo jfh900, el compilador de la casa CCS no hace un tratamiento de la interrupcion del cambio d elos pines del puerto b <4:7> correctamente, concretamente no realiza bien la tarea al abandonar la interrupcion, ya que ellos simplementen borran el flag de la interrupcion(el RBIF) y como bien indica el manual, debemos borrar ese flag pero aparte leer/escribir en el puerto b, asi que nuestro compilador se le 'ha olvidado' esa parte de leer en el puerto b, provocando asi una llamada continua de la funcion de interrupcion, para poner pruebas tenemos el programa del amigo jfh900, y aqui otro:

Este programa consiste en cuatro pulsadores conectados a la parte alta del puerto b, si son presionados cambiaran el estado del bit correspondiente del puerto b generando una interrupcion, en dicha interrupcion, incrementaremos una variable global la cual nos servira en el programa principal para encender led's, aqui el programa:

Código: C

1. ////////////////////////////////////////////////////////////////////////////////////
2. //                                                      VsZeNeR'06             
3. //                                                 01/Julio/06
4. //
5. //      Programa:       Prueba Interrupcion debido a cambio de estado del portb <4:7>
6. //      Version:        0.0
7. //
8. //      Dispositivo: PIC 16F648A                        Compilador:      CCS vs3.249
9. //      Entorno IDE: MPLAB IDE v7.40            Simulador:       Proteus 6.9sp4
10. //
11. //      Notas: Este programa se encarga de ver si el compilador de la casa CCS no desactiva
12. //                 correctamente la interrupcion del puerto b, para ello debe:
13. //                              1. Leer el puerto del puerto B
14. //                              2. Borrar el bit de la interrupcion(bit RBIF)
15. //                 Cada vez que hay un cambio de estado en los pines del puerto B <4:7>
16. //                 se producira una interrupcion, la cual incrementa una variable que se utilizara
17. //                 en el programa principal para mostrar la iluminacion de led's. Aparte,
18. //                 cada vez que se produzca una interrupcion se iluminara un led conectado al pin
19. //                 A4 que se apagara cuando salgamos de dicha interrupcion.
20. //
21. //                 Conexiones:          A0 -> A dec 4028                     
22. //                                                      A1 -> B dec 4028
23. //                                                      A2 -> C dec 4028
24. //                                                      A3 -> D dec 4028
25. //                                                      A4 -> led indicador de interrupcion                    
26. //                                                      B4 -> boton            
27. //                                                      B5 -> boton              
28. //                                                      B6 -> boton          
29. //                                                      B7 -> boton    
30. //
31. //                 Conclusion:  El CCS no realiza bien el tratamiento de la interrupcion
32. //                                              del portB, por lo que tendremos que leer/escribir algun pin
33. //                                              del portB o el puerto entero.
34. //////////////////////////////////////////////////////////////////////////////////
35.  
36. #include <16f648a.h>                                    //pic a utilizar                       
37. #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP             //ordenes para el programador
38. #fuses INTRC                                                    //oscilador interno
39. #use delay (clock=4000000)                              //Fosc=4Mhz
40. #use fast_io(b)
41. #use fast_io(a)
42.  
43.  
44. ///DECLARACION DE VARIABLES GLOBALES
45. int variable=0;        
46.  
47. ///LLAMADA FUNCION INTERRUPCION
48. #INT_RB
49. void IntPortB4_7()
50. {                                      
51.         output_high(pin_a4);            //indicador de interrupcion on
52.  
53. //Activar la linea de abajo para ver los cambios!!!    
54. //      while(!input(PIN_B4) || !input(PIN_B5) || !input(PIN_B6) || !input(PIN_B7));    //elimina rebotes
55. //en caso que funcione el ccs no deberia abordar de nuevo la interrupcion hasta un cambio de estado
56. //de cualquiera de los pines <4:7> del portb. El CCS falla, por lo que si tenemos la linea de lectura/escritura
57. //del puerto b(o alguno de sus pines) desactivada siempre nos entrara en la interrupcion!
58.  
59.         variable++;                                     //incrementamos variable
60.        
61.         if(variable>0b00001001)         //¿se ha iluminado el ultimo led?
62.                 variable=0;                             //SI -> reset variable
63.        
64.         output_low(pin_a4);                     //indicador interrupcion off
65. }
66.  
67. ///PROGRAMA
68. void main(void)
69. {
70.         setup_oscillator(OSC_4MHZ);             //configuramos el oscilador a 4MHz
71.  
72.         set_tris_a (0x00);                              //porta salida
73.         set_tris_b (0xFF);                              //portb entrada
74.        
75.         enable_interrupts(int_rb);              //activar interrupcion rb4:7
76.         enable_interrupts(GLOBAL);              //activar interrupciones
77.        
78.         output_low(pin_a4);                             //indicador de la interrupcion off
79.  
80.         do{                                                             //bucle...
81.                 output_a(variable);                     //mostramos por el porta el valor de variable
82.                 }while(TRUE);                           //...infinito
83. }

Bien, ahora vamos con las explicaciones, el programa tal como esta, si lo simulamos o lo montamos, nos enerara interrupciones siempre, ya que el CCS no realiza correctamente el fin de la interrupcion como es debido, para que funcione correctamente, debemos leer/escribir en el puerto b, vereis que en el programa hay una linea de codigo comentada, es esta:

Código: C

1. while(!input(PIN_B4) || !input(PIN_B5) || !input(PIN_B6) || !input(PIN_B7));    //elimina rebotes

Descomentadla y volver a simular o a cargar el archivo e el pic y ponerlo andar vereis que ya funciona correctamente, esto es debido a que dicha linea, aparte de eliminar los rebotes, lee el estado de alguno de los pines del puerto b, por lo que segun nos dicta el manual, cumplimos correcamente los pasos a seguir para desactivar la interrupcion del puerto b.

En CCS, existe otra funcion la cual limpia las interrupciones: clear_interrupt(level); , la he probado y simplemente borra el bir RBIF, por lo que no nos vale....

Asi que recordar que para un buen tratamiento de la interrupcion del puerto b, tendremos que leer/escribir en dicho puerto para no tener problemas, ya que nuestro compilador no nos hace el trabajo que deberia hacer.

Y con respecto al programa que el amigo Simulpic puso, decir y volver a repetir que la funcion output_log/high no tenia nada que ver en el funcionamiento del porgrama en si para el tratamiento correcto de la funcion de interrupcion, simplemente era de indicador de que la habiamos abordado, lo que pasa que al escribir sobre un pin del puerto b pues ya corregimos el error del CCS...

PD: Supongo que no es un error en si del CCS, quizas no puso la sentencia de lectura del puerto b porque es de esperar que en el abordaje de la interrupcion el programador vea que pin a realizado dicha llamada de interrupcion, por lo que ya estamos leyendo en el puerto b, aunque deberian indicarlo por algun lado...



Suerte!!!

[jfh900]

Totalmente de acuerdo con el mensaje. 
 
Un saludo

[rage78]

Cuando escribes:
printf(lcd_putc,"hola mundo ; )
VsZeNeR"05" ) ;   //muestra por pantalla el mensaje

No entiendo muy bien la forma en que utilizas el printf:
 - Creo que sobra un paréntesis, concretamente el 1º de cierre
 - También sobra unas comillas, concretamente la que van entre VsZener y 05

Puede que me esté equivocando, pero en todo caso si está bien... ¿podrías explicarme el motivo?

Muchas grácias.

[vszener]

Buenas!!!! exactamente sobra unas comillas doble (") las cuales estan entre VsZeNeR y el 05, por lo demas esta todo bien, lo que parece ser que paso, es que al cambiar a este nuevo foro, pues dicha instruccion no se copio correctamente, si te bajas el archivo para ver el programa y simularlo veras que la instruccion correcta es esta:

Código: C

1. printf(lcd_putc,"hola mundo ; ) \nVsZeNeR'05" ); //muestra por pantalla el mensaje

Veras que el primer parentesis de cierre simplemente sirve para conjuntamente con el punto y coma hacer el dibu del guiño, y comprobaras que no existe las segundas comillas entre VsZeNeR y 05, sino una comilla simple, aqui esta el mensaje original antes de ser traspasado a este nuevo foro, veras que tambien esta correcto:
Ejemplitos en C para el 16F648A en mi@

Aconsejo que os bajeis los programas y veais el codigo, ya que estan compilados y simulados, gracias por avisarme!!!


Suerte!!!

[umalrovi]

me sale este mensaje de error a la hora de ejecutar el programa rs232 & keypad.

SIMULATION LOG
==============
Design:   C:\Documents and Settings\Alfonso\Escritorio\vs_rs232&keypad.DSN
Doc. no.: <NONE>
Revision: <NONE>
Author:   <NONE>
Created:  17/09/05
Modified: 17/09/05

Compiling source files...
Processing vs_rs232&keypad.c...
NOT built - requires CCSC
N.B. 3rd party assemblers such as MPASM, ASEM51, ASM11 and AVRASM can be installed using the Proteus SETUP program.

Build FAILED with 1 error(s).



¿SabéIS de que puede ser?

gracias