Presentamos un proyecto el cual hace uso de un microcontrolador pequeño, 16F628A, y que además solamente funciona a pilas, y es muy práctico de implementar y ocupa poco espacio. Se pone énfasis sobre todo en el uso de las interrupciones externas por RB0, mediante el programa CCS o PIC C Compiler. Más concretamente lo que consiste este proyecto, es en un circuito de luces led intermitentes o también conocido como flasher o circuito de destello, la función que cumplen esta clase de luces intermitentes principalmente, es la de servir como distractores o disuasivos para hacer pensar que existe una alarma activada, y en verdad esto sí ocurre con los vehículos que tienen alarmas, pero se lo puede usar también en una casa, y encenderlo en la noche y ponerlo cerca de una ventana para que sea visible, y así de alguna forma hacer pensar a personas que quieren irrumpir en nuestro hogar, que hay una alarma activa. Otro uso que se les puede dar es el de indicadores visibles, sobre todo cuando vamos en bicicleta por la noche y está obscuro, con lo cuál cualquier otra persona que va en bicicleta, o que esté desplazándose en otro vehículo, o que simplemente esté caminando hacia nosotros, se de cuenta de nuestra presencia. Si se desea se puede crear una secuencia específica y acordar esto con alguna otra persona para identificarse mutuamente fácilmente, que se yo, a manera de juego, o simplemente como una pequeña herramienta de aviso en cubierto, en fin.
Una interrupción lo que hace es interrumpir un programa que está en ejecución, o que puede ser tomado en cuenta como principal, para poner en funcionamiento un segundo programa, ya que los microcontroladores se basan en esto para poder ejecutar diferentes programas, es decir el microcontrolador como tal no puede ejecutar varias procesos en paralelo o al mismo tiempo, tiene que ocurrir una interrupción para poder cambiar de programa o proceso. Así mismo hay diferentes formas en que se producen estas interrupciones, y por ende se las activa mediante diferentes sentencias o comandos en el código que se graba en el microcontrolador. Tales interrupciones pueden ser internas o externas. Las internas se dan por cambios en procesos internos del microcontrolador como en la memoria, los temporizadores, el CPU, las externas se dan por cambios externos, y estos cambios son detectados mediante los pines del microcontrolador, pero cada pin o grupos de pines atenderán diferentes tipos de interrupciones en específico, se puede ver también el datasheet de cada tipo de microcontrolador para tener una idea.
En el siguiente vídeo podrán ver con más detalle su implementación, los materiales y el código o programa que se cargará en el microcontrolador, para generar la secuencia de las luces led.
Del vídeo anterior lo que podemos resumir, es que se hace uso de las interrupciones externas mediante el pin RB0, y lo que hace esta interrupción es un cambio de secuencia, y así mismo luego de haberse activada la segunda secuencia mediante la interrupción, se puede retornar a la primera secuencia mediante el accionamiento del interruptor. Pero retornar al programa inicial después de la interrupción pueda que no sea tan fácil como parece, para retornar al programa principal hay que poner las sentencias adecuadas, ya que como en otros proyectos consultados, una vez que se interrumpe el programa principal y se ejecuta la interrupción más de una vez, para ejecutar más de un programa secundario, simplemente no se retorna al programa principal, y simplemente la interrupción se queda funcionando entre los programas secundarios. Por tal motivo siempre es importante tratar de implementar los prototipos de manera física y comprobar que el funcionamiento es el mismo que en la simulación.
Aquí están todos los códigos adjuntos en PIC C compiler para la implementación de este pequeño proyecto:
#include <16f628a.h>
#fuses INTRC_IO,NOWDT,NOPROTECT,PUT,NOLVP,NOMCLR//Los fuses a destacar son el INT_RC que habilita el oscilador interno, y NOMCLR deshabilita el master clear
#use delay(clock=4M)//Frecuencia del oscilador interno es 4 MHz
#use fast_io(a)
#use fast_io(b)
#int_ext //Declaramos la función de interrupción externa por RB0.
void Interrupt()//Programa a ejecutarse al habilitar la Interrupción
{
while(input(pin_b0)==0){ //Se ejecuta mientras esta pulsado interruptor de RB0, segunda secuencia
int i=0;//Inicializando variable de iteración del buble for, primer efecto
int j=0;//Inicializando variable de iteración del buble for, segundo efecto
for(i=1;i<5;i++){ //Empezando primer efecto de la segunda secuencia
output_a(0xA);//PORTA=00101
delay_ms(250);// retardo 250 milisegundos.
output_a(0x05);//PORTA=01010
delay_ms(250);
output_a(0x00);//PORTA=00000
delay_ms(250);
}
for(j=1;j<5;j++){ //Empezando segundo efecto de la segunda secuencia
output_a(0x01);//PORTA=00001
delay_ms(250);
output_a(0x03);//PORTA=00011
delay_ms(250);
output_a(0x07);//PORTA=00111
delay_ms(250);
output_a(0xF);//PORTA=01111
delay_ms(250);
output_a(0x00);//PORTA=00000
delay_ms(250);
}
}
}
void main()//Programa Principal
{
set_tris_b(0x01);//RB0:In (entrada)
set_tris_a(0x00);//Port a:Out (salida)
output_a(0x00);//Se inicializa Port a = 0x00
port_b_pullups(true);//Habilitamos las resistencias pull up del puerto B
enable_interrupts(global);//Habilito las Interrupciones en Forma Global
enable_interrupts(int_ext);//Habilito la interrupción externa por RBO
ext_int_edge(H_TO_L);//La Interrupción se da cuando sucede el cambio de estado:de 1 a 0, ó flanco de bajada
int i=0;//Inicializando variable de interación del buble for, primer efecto
int j=0;//Inicializando variable de iteración del buble for, segundo efecto
while(true)
{
while(input(pin_b0)==1){ //Se ejecuta mientras esta abierto el interruptor de RB0, primera secuencia
for(i=1;i<5;i++){ //Empezando primer efecto de la primera secuencia
output_a(0x01);//PORTA=00001
delay_ms(250);// retardo 250 milisegundos.
output_a(0x02);//PORTA=00010
delay_ms(250);
output_a(0x04);//PORTA=00100
delay_ms(250);
output_a(0x08);//PORTA=01000
delay_ms(250);
}
for(j=1;j<5;j++){ //Empezando segundo efecto de la primera secuencia
output_a(0x01);//PORTA=00001
delay_ms(250);
output_a(0x02);//PORTA=00010
delay_ms(250);
output_a(0x01);//PORTA=00001
delay_ms(250);
output_a(0x02);//PORTA=00010
delay_ms(250);
output_a(0x04);//PORTA=00100
delay_ms(250);
output_a(0x02);//PORTA=00010
delay_ms(250);
output_a(0x04);//PORTA=00100
delay_ms(250);
output_a(0x08);//PORTA=01000
delay_ms(250);
output_a(0x04);//PORTA=00100
delay_ms(250);
output_a(0x08);//PORTA=01000
delay_ms(250);
output_a(0x01);//PORTA=00001
delay_ms(250);
output_a(0x08);//PORTA=01000
delay_ms(250);
}
}
}
}
En fin, se trata de un proyecto muy simple, que pretende usar las interrupciones con el fin más práctico posible, aplicado a situaciones más reales y de uso más cotidiano.
Otro uso que se les puede dar a esta clase de circuitos de luces led es el de una simple decoración, y si se desea personalizar o cambiar la secuencia ya establecida en este proyecto, usarlos en tiendas, negocios, o en nuestra sala como luces navideñas, etc. Poner luces personalizadas también puede ser una forma de realzar la presentación de un determinado sitio, o tratar de llamar más la atención.
Muchas personas también piden aprender realizar esta clase de proyectos sin el uso de circuitos integrados, por tal motivo en una siguiente publicación se realizará un proyecto similar.
No hay comentarios.:
Publicar un comentario