Ejemplitos en C para 16F648A

Colección de ejemplos en C para pic tomados de la red
http://todopic.mforos.com/46840/4061462-ejemplitos-en-c-para-16f648a/
Ejemplitos en C para 16F648A
Y aqui va la version de contador de 0a9 en display de 7 segmento formato BCD y boton...peo esta
vez dos botones, uno por el pin A0 que sis e pulsa se incrementa un digito y s emuestra por el
7seg BCD y otro boton por el pin A1 que si se pulsa se decrementa en una unidad y s emuestra
por display de 7seg BCD:
////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR'05
// 22/Agosto/05
//
// Programa: Contador 0-9 display BDC & Boton para cuenta ascendente o descendente
// Version: 0.0
//
// Dispositivo: PIC 16F648A Compilador: CCS vs3.227
// Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3
//
// Notas: Contador 0 al 9 cada vez que pulsemos el boton y vuelta a empezar. Tener
// en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
// salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta
// que este dispositivo genera 'rebotes' que hay que ser eliminados para
// una correcta visualizacion en el display del digito seleccionado. Esta vez
// la eliminacion de 'los rebotes' se ha realizado mediante software.
// Cuando por el pin A0 del porta se introduce un '0' logico(low), se
// incrementa un digito en el display BCD, encambio si por el pin A1 se introduce
// un '0' logico(low) se decrementa en una unidad el digito a mostrar.
//
// Conexiones: A0 -> boton up(cuenta ascendente)
// A1 -> boton down(cuenta descendente)
// B0 -> a
// B1 -> b
// B2 -> c
// B3 -> d
// BCD:
// d c b a NUM
// 0 0 0 0 0
// 0 0 0 1 1
// 0 0 1 0 2
// 0 0 1 1 3
// 0 1 0 0 4
// 0 1 0 1 5
// 0 1 1 0 6
// 0 1 1 1 7
// 1 0 0 0 8
// 1 0 0 1 9
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h> //pic a utilizar

#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
#use standard_io(A)
///PROGRAMA
void main(void)
{
signed char i=0; //contador para tabla BCD
int
tabBCD[10]={0b0000,0b0001,0b0010,0b0011,0b0100,0b0101,0b0110,0b0111,0b1000,0b1001};
//BCD 0-9
set_tris_a(0xFF); //porta como entrada

disable_interrupts(GLOBAL); //todas las interrupciones desactivadas
output_b(tabBCD[ i ]); //inicializa displayBCD digito 0
for( ; ; ){ //bucle...
if(!input(PIN_A0)) //¿se ha pulsado el boton up?
{
delay_ms(151); //SI -> retardo para evitar los rebotes
i++; //incremento contador indice tabBCD
if(i>9) //¿se ha mostrado digito 9?
i=0; //SI -> restaura valor indice(para mostrar digito 0)
}
if(!input(PIN_A1)) //¿se ha pulsado el boton down?
{
delay_ms(151); //SI -> retardo para evitar los rebotes
i--; //decremento contador indice tabBCD
if(i<0) //¿se ha mostrado digito 0?
i=9; //SI -> restaura valor indice(para mostrar digito 9)
}
output_b(tabBCD[ i ]); //muestra por portb digito BCD
} //...infinito
}
Recordad que los botones generan los llamados 'rebotes' que deben ser eliminados bien hardware
o bien por software(el cual es este ejemplo mediante una pausa de 151ms)....corto y cambio!!!
Bueno celebrando mi mensaje numero 100!!!(parece que fue ayer...)aqui un ejemplito massss de
contador en display's de 7seg...ya se que estais cansados de ver numeritos y mas numeritossss
jeje pero weno asi ya sabemos programar display's de 7seg multiplexados, interrupciones y demas
cositas...esta vez es un SUPER CONTADOR!!!!!jeje ascendente(de momento) que cuenta de 0000
a 9999 y vuelta a empezar....bueno compañeros, ya no hay excusa que no sabemos contar!!!!:
////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR'05
// 23/Agosto/05
//
// Programa: Contador del 0000 al 9999
// Version: 0.0
//
//
// Notas: Contador del 0000 al 9999 cada 1s y vuelta a empezar. Tener en cuenta
// que hay que poner la directiva NOLVP para que el pin B4 sea de salida.
// Se utiliza variables locales:
// * i -> indice tabla 7seg para mostrar digito por 1º 7seg
// * j -> indice tabla 7seg para mostrar digito por 2º 7seg
// * w -> indice tabla 7seg para mostrar digito por 3º 7seg
// * z -> indice tabla 7seg para mostrar digito por 4º 7seg
// * flag -> variable que cuenta 1s
// * var -> ajuste fino para que desborde cada segundo
// Utilizamos la funcion de interrupcion para actualizar indices de la
// tabla de 7seg para mostrar el digito correspondiente en el respectivo
// 7seg, para ello el TMR0 se desborda cada 1s, para ello debe ser cargado
// con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
// un desbordamiento de 1s utilizamos una variable(flag) que no entra en
// la actualizacion de indices hasta transcurrido 1s.
// Conexiones:
// · RA0 -> Display 1º 7seg
// · RB0 -> a 7seg
// · RB1 -> b 7seg
// · RB2 -> c 7seg
// · RB3 -> d 7seg
// · RB4 -> e 7seg
// · RB5 -> f 7seg
// · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#use standard_io(B)
#use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3) //A0,A1,A2,A3 como salidas en porta
char i=0,j=0,w=0,z=0,flag=0,var=20; //variables globales
///LLAMADA FUNCION INTERRUPCION

#INT_TIMER0
void interrupcion()
{
if(flag>var){ //¿ya es 1 segundo?
var--; //SI -> decremento var...
if(var<18)
var=20; //...ajuste fino de 1s
flag=0; //reset flag para contar 1s
if(i>8){ //¿se ha mostrado por 1º 7seg digito 9?
i=0; //SI -> i=0 (muestra digito 0) (*)
j++; //incremento indice j
if(j>9){ //¿se ha mostrado por 2º 7seg digito 9?
j=0; //SI -> j=0 (muestra digito 0)
w++; //incremento indice w
if(w>9){ //¿se ha mostrado por 3º 7seg digito 9?
w=0; //SI -> w=0 (muestra digito 0)
z++; //incremento indice z
if(z>9) //¿se ha mostrado por 4º 7seg digito 9?
z=0; //SI -> z=0 (muestra digito 0)
}
}
}
else{ //(*) NO -> incrementa i
i++;}
}
set_timer0(61); //reset TMR0
flag++; //incremento variable flag
}
///PROGRAMA
void main(void)
{
int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67}; //7seg hex 0-9
set_tris_b(0x00); //portb como salida

enable_interrupts(INT_TIMER0); //interrupcion TIMER0 activada
setup_counters(RTCC_INTERNAL,RTCC_DIV_256); //configuracion interrupcion TMR0
set_timer0(61); //carga TMR0
enable_interrupts(GLOBAL); //activadas interrupciones
do{ //bucle...
output_high(PIN_A0);
output_low(PIN_A3); //activado...
output_b(tab7seg[ i ]); //...1º 7seg
delay_ms(10);
output_b(tab7seg[ j ]); //...2º 7seg
delay_ms(10);
output_b(tab7seg[ w ]); //...3º 7seg
delay_ms(10);
output_b(tab7seg[ z ]); //...4º 7seg
delay_ms(10);
}while(TRUE); //...infinito
}
////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR'05
// 24/Agosto/05
//
// Programa: BETI parpadeo
// Version: 0.0
//
//
// Notas: Muestra el mensaje de BETI por cuatro display's de 7 segmentos
// multiplexados. El mensaje aparece cada 0,5s parpadeando
// Tener en cuenta que hay que poner la directiva NOLVP
// para que el pin B4 sea de salida.
// * i -> contador para visualizar BETI
// Conexiones:
// · RB0 -> a 7seg
// · RB1 -> b 7seg
// · RB2 -> c 7seg
// · RB3 -> d 7seg
// · RB4 -> e 7seg
// · RB5 -> f 7seg
// · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#use standard_io(B)
#use standard_io(A)
///PROGRAMA
void main(void)
{
char i; //contador de visualizacion BETI

set_tris_a(0x00); //porta como salida
disable_interrupts(GLOBAL); //activadas interrupciones
do{ //bucle...
for(i=0;i<15;i++){ //bucle visualizacion beti
output_a(0b1110);
output_b(0x7C); //1º 7seg on B
delay_ms(10);
output_a(0b1101);
output_b(0x79); //2º 7seg on E
delay_ms(10);
output_a(0b1011);
output_b(0x78); //3º 7seg on T
delay_ms(10);
output_a(0b0111);
output_b(0x30); //4º 7seg on I
delay_ms(10);
}
output_b(0x00); //todo...
output_a(0b0000);
delay_ms(500); //...apagado durante 0,5s
}
jejeje la virgen!!!!jeje la verdad que el chiko no se compliko la cabeza mucho....y yo ke kreia ke
radon estaba hablando en broma de eso de tumbar los 7seg.....jeje ke descaro!..ainsss por cierto
xootraoox interesante el data sheet que pusiste haber si lo leo detenidamente me interesan los
'chismes' esos....bueno se que al Depor le hace mas falta los animos ya que no estamos en europa
ni nada asi que haciendole caso a nocturno66 aqui va el programita que anima al depor diciendo:
AUPA DEPO y suena un pitidito....como mejor he podido poner las letras en display's de 7seg jeje:
////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR'05
// 25/Agosto/05
//
// Programa: AUPA DEPO parpadeo
// Version: 0.0
//
//
// Notas: Muestra el mensaje de AUPA DEPO por cuatro display's de 7 segmentos
// multiplexados. El mensaje aparece cada 0,5s parpadeando primero la
// frase AUPA y luego la frase DEPO y suena un pitido al cambio de frase.
// * i -> indice 1º 7seg
// * j -> indice 2º 7seg
// * w -> indice 3º 7seg
// * z -> indice 4º 7seg
// * cont -> contador: cont=0 -> AUPA
// cont=1 -> DEPO
// * rep -> variable para visualizar mensaje
// * tab7seg[] -> vector donde se almacenan letras mensajes
// Conexiones:
// · RB0 -> a 7seg
// · RB1 -> b 7seg
// · RB2 -> c 7seg
// · RB3 -> d 7seg
// · RB4 -> e 7seg
// · RB5 -> f 7seg
// · RB6 -> g 7seg
// · RB7 -> Buzzer
//////////////////////////////////////////////////////////////////////////////////

#use standard_io(B)
#use standard_io(A)
///PROGRAMA
void main(void)
{
char rep,cont=0,i=0,j=1,w=2,z=0; //variables
int tab7seg[6]={0x77,0x3E,0x73,0x5E,0x79,0x3F}; //A U P D E O

disable_interrupts(GLOBAL); //desactivadas interrupciones
do{ //bucle...
for(rep=0;rep<15;rep++){ //bucle visualizacion aupa/depo
output_a(0b1110);
output_b(tab7seg[ i ]); //1º 7seg on
delay_ms(10);
output_a(0b1101);
output_b(tab7seg[ j ]); //2º 7seg on
delay_ms(10);
output_a(0b1011);
output_b(tab7seg[ w ]); //3º 7seg on
delay_ms(10);
output_a(0b0111);
output_b(tab7seg[ z ]); //4º 7seg on
delay_ms(10);
}
cont=!cont; //cont=~cont
if(cont==1){ //muestra:
i=3; //D
j=4; //E P
z=5;} //O
else{ //muestra:
i=0; //A
j=1; //U P
z=0;} //A
output_b(0b10000000); //Buzzer on...todo...

output_a(0b0000);
delay_ms(500); //...apagado durante 0,5s
Un ejemplito mas!!!!y seguimos machacando los display's de 7 segmentos de catodo comun...esta
vez el ejemplo consiste en 4 display's de 7seg mostrar la palabra 'hola' e ir rotandola hacia la
izquierda:
////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR'05
// 21/Agosto/05
//
// Programa: HOLA
// Version: 0.0
//
//
// Notas: Muestra el mensaje de HOLA por cuatro display's de 7 segmentos
// multiplexados. El mensaje se va rotando por los display's hacia la
// izquierda. Tener en cuenta que hay que poner la directiva NOLVP
// * i -> indice tabla 7seg para mostrar 1º 7seg
// * j -> indice tabla 7seg para mostrar 2º 7seg
// * z -> indice tabla 7seg para mostrar 3º 7seg
// * w -> indice tabla 7seg para mostrar 4º 7seg
// * flag -> variable que cuenta 0.5s
// * var -> ajuste fino para que desborde cada medio segundo.
// Utilizamos la funcion de interrupcion para actualizar indices de la
// tabla de 7seg para mostrar la palabra correspondiente en el respectivo
// 7seg, para ello el TMR0 se desborda cada 0.5s, para ello debe ser cargado
// con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
// un desbordamiento de 0.5s utilizamos una variable(flag) que no entra en
// la actualizacion de indices hasta transcurrido 0.5s.
// Conexiones:
// · RB0 -> a 7seg
// · RB1 -> b 7seg
// · RB2 -> c 7seg
// · RB3 -> d 7seg
// · RB4 -> e 7seg
// · RB5 -> f 7seg
// · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#use standard_io(B)
#use standard_io(A)
char i=0,j=1,z=2,w=3,var=10,flag=0; //indices para tabla 7 seg
///LLAMADA FUNCION INTERRUPCION

#INT_TIMER0
void interrupcion()
{
if(flag>var){ //¿ya es 1 segundo?
var--; //SI -> decremento var...
if(var<18)
var=10; //...ajuste fino de 1s
flag=0; //reset flag para contar 1s
i++; //incrementos...
j++;
z++;
w++; //...indices para mostrar en 7seg
if(i>3) //¿Ha llegado fin tab7seg?
i=0; //SI -> restaura indice i
if(j>3) //¿Ha llegado fin tab7seg?
j=0; //SI -> restaura indice j
if(z>3) //¿Ha llegado fin tab7seg?
z=0; //SI -> restaura indice z
if(w>3) //¿Ha llegado fin tab7seg?
w=0; //SI -> restaura indice w
}
set_timer0(61); //reset TMR0

flag++; //incremento variable flag
}
///PROGRAMA
void main(void)
{
int tab7seg[4]={0x76,0x3F,0x38,0x77}; //7seg H O L A

enable_interrupts(INT_TIMER0); //interrupcion TIMER0 activada
setup_counters(RTCC_INTERNAL,RTCC_DIV_256); //configuracion interrupcion TMR0
set_timer0(61); //carga TMR0
enable_interrupts(GLOBAL); //activadas interrupciones
do{ //bucle...
output_b(tab7seg[ i ]); //...1º 7seg
delay_ms(10);
output_b(tab7seg[ j ]); //...2º 7seg
delay_ms(10);
output_b(tab7seg[ z ]); //...3º 7seg
delay_ms(10);
output_b(tab7seg[ w ]); //...4º 7seg
delay_ms(10);
}
Bueno....terminada la publicidad y animos a los equipos de futbol como el que no quiere la cosa
sabemos contar de forma ascendente,descendente,automatica,con botones,parpadeo de
palabras,parpadeo de dos palabras y ahora rotar palabras....ya sabemos
Aqui va otro ejemplito mas!!!!y mas con 7seg!!!!jeje ke jartura de estos dispositivos......ainsss
jeje, bueno esta vez consiste en mostrar por pantaya un cuadradito ke se desplaza de izquierda a
derechas y viceversa:
////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR'05
// 26/Agosto/05
//
// Programa: Cuadrado que recorre 4 display's de 7seg de izuiqerda a derechas
// Version: 0.0
//
//
// Notas: Simbolo recorre cuatro display's de 7 segmentos de izquierda
// a derechas y viceversa.
// * i -> contador de display on
// * display_on[] -> vector con el display on
// Conexiones:
// · RB0 -> a 7seg
// · RB1 -> b 7seg
// · RB2 -> c 7seg
// · RB3 -> d 7seg
// · RB4 -> e 7seg
// · RB5 -> f 7seg
// · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#use standard_io(B)
#use standard_io(A)
///PROGRAMA
void main(void)
{
char i=0; //contador de display on
int display_on[4]={0b1110,0b1101,0b1011,0b0111}; //tabla display on

disable_interrupts(GLOBAL); //desactivadas interrupciones
output_b(0x63); //muestra por pantalla simbolo

output_a(display_on[ i ]); //inicializo display
do{ //bucle...
for(i=0;i<3;i++){ //hacia la izquierda
delay_ms(100);
output_a(display_on[ i ]);
}
for(i=3;i>0;i--){ //hacia la derecha

delay_ms(100);
output_a(display_on[ i ]);
}
}

Ejemplitos en C para 16F648A

Cargado por

Copyright:

Formatos disponibles

Ejemplitos en C para 16F648A

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ejemplitos en C para 16F648A

Cargado por

Copyright:

Formatos disponibles

Colección de ejemplos en C para pic tomados de la red

Ejemplitos en C para 16F648A

#include <16f648a.h> //pic a utilizar

set_tris_a(0xFF); //porta como entrada

#include <16f648a.h> //pic a utilizar

char i=0,j=0,w=0,z=0,flag=0,var=20; //variables globales

///LLAMADA FUNCION INTERRUPCION

set_tris_b(0x00); //portb como salida

#include <16f648a.h> //pic a utilizar

set_tris_b(0x00); //portb como salida

#include <16f648a.h> //pic a utilizar

set_tris_b(0x00); //portb como salida

output_b(0b10000000); //Buzzer on...todo...

#include <16f648a.h> //pic a utilizar

char i=0,j=1,z=2,w=3,var=10,flag=0; //indices para tabla 7 seg

///LLAMADA FUNCION INTERRUPCION

set_timer0(61); //reset TMR0

set_tris_b(0x00); //portb como salida

#include <16f648a.h> //pic a utilizar

set_tris_b(0x00); //portb como salida

output_b(0x63); //muestra por pantalla simbolo

for(i=3;i>0;i--){ //hacia la derecha

También podría gustarte