Practicas 1

17/03/2
0014
Manual Practicas Pic en C
JOSE ANTONIO LINERO MADRID

SALESIANOS ,MALAGA
17/03/20014
INDICE
1. Parpadeo de un led cada 0.5 seg.
2. Parpadeo de tres led cada 0.5 seg.
3. Parpadeo de cuatro led cada 0.5 seg.
4. Coche fantstico v1.
5. Juego de luces.
6. Contador ascendente.
7. Contador 0 a 9 BCD&Boton.
8. Sper contador 0000a9999 (7 seg.)
9. Dado digital (7 seg).
10. Hola Mundo (Lcd).
11. Abecedario (Lcd).
12. Dado digital (Lcd).
13. Reloj-Calendario Rs232.
14. Termmetro Digital con ds1620.

Herramientas
MPlab IDE -> Entorno de trabajo
CCS Plug-in MPlab -> Integrar nuestro compilador CCS al entrono MPlab
CCS Demo -> Una version demo de nuestro compilador
Manual CCS -> Manual de nuestro compilador en espaol
7Seg -> Programa que genera el codigo de display"s 7segmentos(ac & cc)
LCD 5x7 -> Programa que genera codigo para caracteres cgram LCD 5x7
ASCII & RCC -> Programas para obtener codigo ASCII y RCC para colores resistor
1. Parpadeo de un led cada 0.5 seg.
//Programa: Parpadeo de un led cada 0.5s

//Version: 0.0
//
//Dispositivo: PIC 16F648A Compilador: CCS vs3.227
//Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3
//
//Notas: Parpadeo de un led cada 0.5s por el pin RB0 del puerto B
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h> //pic a utilizar

#fuses XT,NOWDT,NOPROTECT,PUT //ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz
#use fast_io(b)
///PROGRAMA
void main(void)
{
set_tris_b(0xFE); //portb como salida(RB0,las demas desactivadas)
disable_interrupts(GLOBAL); //todas las interrupciones desactivadas
do{
output_low(PIN_B0); //led off
delay_ms(500);
output_high(PIN_B0); //led on
delay_ms(500);
}while(TRUE); //bucle infinito
}
2. Parpadeo de tres led cada 0.5 seg.
//Programa: Parpadeo de tres leds cada 0.5s
//Version: 0.1
//
//Dispositivo: PIC 16F648A Compilador: CCS vs3.227
//Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3
//
//Notas: Parpadeo de tres leds cada 0.5s de tres formas diferentes:
// RB0 -> con la funcion output_high()/output_low()
// RB1 -> definiendo el pin RB1
// RB2 -> con la funcion output_bit()
//////////////////////////////////////////////////////////////////////////////////

#fuses XT,NOCPD,NOWDT,NOPUT,NOLVP,NOBROWNOUT //ordenes programador
#use fast_io(b)
#bit RB1=0x106.1 //definicion pin potrb B1
///PROGRAMA
void main(void)
{
set_tris_b(0xF8); //puerto b como salida
disable_interrupts(GLOBAL); //todas interrupciones desactivadas
RB1=0; //valor inicial B1 para que los led"s se iluminen igual

do{
output_high(PIN_B0); //led"s on
RB1=!RB1;
output_bit(PIN_B2,1);
delay_ms(500);
output_low(PIN_B0); //led"s off

RB1=!RB1;
delay_ms(500);
}
3. Parpadeo de cuatro led cada 0.5 seg
// Programa: Parpadeo de cuatro leds cada 0.5s
// Version: 0.2
//
// Dispositivo: PIC 16F648A Compilador: CCS vs3.227
// Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3
//
// Notas: Parpadeo de cuatro leds cada 0.5s de cuatro formas diferentes:
// RB0 -> con la funcion output_high()/output_low()
// RB1 -> definiendo el pin RB1
// RB2 -> con la funcion output_bit()
// RB3 -> con la funcion bit_set()/bit_clear()
//////////////////////////////////////////////////////////////////////////////////

#fuses XT,NOCPD,NOWDT,NOPUT,NOLVP,NOBROWNOUT //ordenes para el programador
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3) //pin de salida portb
#bit RB1=0x106.1 //definicion pin potrb B1
#byte portb=06
///PROGRAMA
void main(void)
{
set_tris_b(0x00); //puerto b como salida
disable_interrupts(GLOBAL); //todas interrupciones desactivadas
RB1=0; //valor inicial B1 para que los led"s se iluminen igual

do{
output_high(PIN_B0); //led"s on
RB1=!RB1;
bit_set(portb,3);
delay_ms(500);
output_low(PIN_B0); //led"s off

RB1=!RB1;
bit_clear(portb,3);
delay_ms(500);
}
4. Coche fantstico v1.
// Programa: Coche Fantastico
// Version: 0.0
//
//
// Notas: Barrido de led"s simulando la iluminacion del coche fantastico por el
// puerto A
//
// RA0 -> 1 Led
// RA1 -> 2 Led
// RA2 -> 3 Led
// RA3 -> 4 Led
//////////////////////////////////////////////////////////////////////////////////

#fuses XT,NOWDT,NOPROTECT,PUT //ordenes para el programador
#use standard_io(A) //puerto A como salida
///DECLARACIONES DE FUNCIONES
void derecha(void); //ilumina led"s derecha a izquierda
void izquierda(void); //ilumina led"s izquierda a derecha
///PROGRAMA
void main(void)
{
set_tris_a(0xF0); //porta como salida menos RA4(desactivado)
do{ //bucle...
derecha();
izquierda();
}while(TRUE); //...infinito
}
void derecha(void)
{
output_high(PIN_A0);
delay_ms(300);
output_low(PIN_A0);
delay_ms(300);
output_low(PIN_A1);
delay_ms(300);
output_low(PIN_A2);
delay_ms(300);
}
void izquierda(void)
{
output_low(PIN_A3);
delay_ms(300);
output_low(PIN_A2);
delay_ms(300);
output_low(PIN_A1);
}
5. Juego de luces
// Programa: Juego de luces
// Version: 0.0
//
//
// Notas: Iluminacion de juego de luces fuera-dentro y viceversa por el puerto B.
// Adaptacion a c por vszener del codigo en basic de lordlafebre.
//
// RB0 -> 1 Led
// RB1 -> 2 Led
// RB2 -> 3 Led
// RB3 -> 4 Led
// RB4 -> 5 Led
// RB5 -> 6 Led
// RB6 -> 7 Led
// RB7 -> 8 Led
//////////////////////////////////////////////////////////////////////////////////

#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador
#use standard_io(B) //puerto B
///PROGRAMA
void main(void)
{
signed char i; //variable indice
int leds[4]={0b10000001,0b01000010,0b00100100,0b00011000}; //led"s
set_tris_b(0x00); //portb como salida

do{ //bucle...
for(i=0;i<4;i++){ //led"s on fuera-dentro

output_b(leds[ i ]); //ilumino led"s correspondientes
delay_ms(100);
}
for(i=3;i>-1;i--){ //led"s on dentro-fuera
output_b(leds[ i ]); //ilumino led"s correspondientes
delay_ms(100);
}
}
6. Contador ascendente.
// Programa: Contador ascendente 0-9
// Version: 0.0
//
//
// Notas: Contador del 0 al 9 cada 0,5s y vuelta a empezar. Tener en cuenta
// que hay que poner la directiva NOLVP para que el pin B4 sea de salida
//////////////////////////////////////////////////////////////////////////////////

#use standard_io(B)
///PROGRAMA
void main(void)
{
char i=0; //contador para tabla 7 seg
int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67}; //7seg hex 0-9

do{ //bucle...
output_b(tab7seg[ i ]); //muestra por portb digito 7 segmentos
delay_ms(500);
i++; //incremento contador para visualizar siguiente digito
if(i>9) //ya se ha mostrado el digito 9?
{
i=0; //SI -> vuelve a empezar(digito 0)
}
}
7. Contador 0 a 9 BCD&Boton.
// Programa: Contador 0-9 display BDC & Boton
// Version: 0.0
//
//
// 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.
//
// Conexiones: A0 -> boton
// B0 -> a
// B1 -> b
// B2 -> c
// B3 -> d
// BCD:
// d c b a NUM
// 0000 0
// 0001 1
// 0010 2
// 0011 3
// 0100 4
// 0101 5
// 0110 6
// 0111 7
// 1000 8
// 1001 9
//////////////////////////////////////////////////////////////////////////////////

#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
#use standard_io(A)
///PROGRAMA
void main(void)
{
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
output_b(tabBCD[i]); //inicializa displayBCD digito 0
for(;;){ //bucle...
if(!input(PIN_A0)) //se ha pulsado el boton?
{
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)
output_b(tabBCD[i]); //muestra por portb digito 7
segmentos
}
} //...infinito
}
8. Sper contador 0000a9999 (7 seg.)
// 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>Cool{ //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

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_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);
}
9. Dado digital (7 seg).
// Programa: Dado digital
// Version: 0.0
//
//
// Notas: Dado digital, que al presionar el boton conectado al pin A0 del porta
// genera un numero pseudo-aleatorio mediante la funcion rand() que se
// encuentra en la libreria STDLIB.H. El numero pseudo-aleatorio es elegido
// mediante la funcion rand() y segun los "rebotes" producidos por el boton.Tener
// 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.
//
// B0 -> a
// B1 -> b
// B2 -> c
// B3 -> d
// BCD:
// d c b a NUM
// 0000 0
// 0001 1
// 0010 2
// 0011 3
// 0100 4
// 0101 5
// 0110 6
// 0111 7
// 1000 8
// 1001 9
//////////////////////////////////////////////////////////////////////////////////

#include <STDLIB.H> //libreria donde esta la funcion rand();
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
#use standard_io(A)
///PROGRAMA
void main(void)
{
char num=0; //variable almacena numero aleatorio

srand(10); //maximo hasta 9

for( ; ; ){ //bucle...
{
do{ //elimina...
num=rand(); //genera numero pseudo-aleatorio
}while(!input(PIN_A0)); //...rebotes
}
output_b(num); //muestra por portb digito 7 segmentos
} //...infinito
}
10. Hola Mundo (Lcd).
// Programa: Hola mundo
// Version: 0.0
//
//
// Notas: Se muestra por pantalla de lcd(LM016L) en la primera linea la
// frase "hola mundo Gio" y en la segunda linea "VsZeNeR"05". Tener
// salida.
//
// Conexiones: B0 -> E
// B1 -> RS
// B2 -> RW
// B4 -> D4
// B5 -> D5
// B6 -> D6
// B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#define use_portb_lcd TRUE //definir portb lcd
#include<lcd.c> //libreria manejo lcd
///PROGRAMA
void main(void)
{
lcd_init(); //inicializa lcd
printf(lcd_putc,"hola mundo ; )
VsZeNeR"05" ); //muestra por pantalla el mensaje
}
11. Abecedario (Lcd).
// Programa: Abecedario
// Version: 0.0
//
//
// Notas: Se muestra por pantalla de lcd(LM016L) el abecedario y vuelta a empezar
// Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
// salida.
// abecedario[] -> vector donde se almacena abecedario
// x -> indice para vector abecedario e indice para columna lcd
// y -> indice para fila lcd: y=1 -> Fila 1
// y=2 -> Fila 2
// Conexiones: B0 -> E
// B1 -> RS
// B2 -> RW
// B4 -> D4
// B5 -> D5
// B6 -> D6
// B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

///PROGRAMA
void main(void)
{
char abecedario[27]={"
","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","
z"},x,y=1; //tabla y variables definidas
do{ //bucle...
for(x=1;x<27;x++){ //bucle para mostrar digito
if(y==1) //1 fila del lcd
lcd_gotoxy(x,y);
else //2 fila del lcd
lcd_gotoxy((x-16),y);
if(x>15) //ya esta completa la 1 fila del lcd?

y=2; //SI -> escribe en 2 fila
printf(lcd_putc,"%c",abecedario[ x ]); //muestra por pantalla el caracter

delay_ms(300);
}
printf(lcd_putc,"f " ) ; //borra pantalla del lcd
y=1; //restablece indice
}
12. Dado digital (Lcd).
// Programa: Dado digital con lcd y buzzer
// Version: 0.0
//
//
// Notas: Dado digital, que al presionar el boton conectado al pin A0 del porta
// genera un numero pseudo-aleatorio mediante la funcion rand() que se
// encuentra en la libreria STDLIB.H. El numero pseudo-aleatorio es elegido
// mediante la funcion rand() y segun los "rebotes" producidos por el boton.Tener
// 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 la lcd del digito seleccionado. Esta vez
// la eliminacion de "los rebotes" se ha realizado mediante software.
//
// B0 -> E
// B1 -> RS
// B2 -> RW
// B4 -> D4
// B5 -> D5
// B6 -> D6
// B7 -> D7
// B3 -> Buzzer(beep)
//////////////////////////////////////////////////////////////////////////////////

#define RAND_MAX 7 //dado solamente 6 numeros
#include <STDLIB.H> //libreria donde esta la funcion rand();
#use standard_io(B)
#use fast_io(A)
///PROGRAMA
void main(void)
{
char num=0; //variable almacena numero aleatorio

srand(10); //maximo hasta 9

lcd_putc("Dado Electronico
Pulse boton..." );
while(input(PIN_A0)){} //Se mantiene cabecera hasta que se pulse el boton
lcd_putc("fDado:
VsZeNeR"05" );
lcd_gotoxy(7,1); //Coordenadas dond se muestra el numero
for( ; ; ){ //bucle...
{
do{ //SI -> elimina...
num=rand(); //genera numero pseudo-aleatorio
}while(!input(PIN_A0)); //...rebotes
printf(lcd_putc,"%d",num); //muestra por lcd numero

lcd_putc("" ); //retrocede un espacio
output_high(PIN_B3); //activa buzzer(beep)
delay_ms(50); //tiempo de escucha del beep
output_low(PIN_B3); //desactiva buzzer(beep)
}
} //...infinito
}
13. Reloj-Calendario Rs232
// Programa: Reloj-Calendario DS1302 y RS232
// Version: 1.0
//
//
// Notas: Se muestra por virtual terminal la fecha y hora obtenida mediante la
// lectura del DS1302. Pudiendose modificar mediante los botones Conf/Ok y up.
// Se utiliza variables globales:
// day-> dia ds1302
// mth -> mes ds1302
// year -> ao ds1302
// hour -> hora ds1302
// min -> minutos ds1302
// sec-> segundos ds1302
// menu -> variable que muestra opcion del menu configurar
// flag -> variable que cuenta hasta 130ms aprox./ tb vale como control menu
// var -> ajuste fino para que desborde cada 130ms aprox.
// Se carga el TMR0 con 0 por lo tanto se desborda en 65ms aprox, queremos
// visualizar y restaurar valores cogidos del ds1302 cada 130ms aprox por lo tanto
// utilizamos una variable llamada flag que sera la encargada de dicha tarea.
// Al inicio del programa debe ser configurado el reloj, siendo el boton "up" el
// encargado de ir moviendose mediante las opciones del menu:hora,minutos,....
// y el boton "Conf/Ok" el encargado de configurar el reloj(cuando estemos en modo ver
// hora y fecha) o el encargado de salir de la configuracion de las opciones(cuando
// estemos en formato de configurar fecha y hora).
// Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
// salida.
// Conexiones: A0 -> RST DS1302
// A1 -> SCLK DS1302
// A2 -> I/O DS1302
// A3 -> Boton "up"
// A5 -> Boton "Conf/Ok"
// B1 -> Tx
// B2 -> Rx
// B3 -> Zumbador(beep)
//////////////////////////////////////////////////////////////////////////////////

#use delay(CLOCK=4000000) //Fosc=4Mhz
#fuses HS,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP,NOWDT,NOMCLR //comandos para el
programador
#use standard_io(a)
#use standard_io(b)
#use rs232(baud=9600, xmit=PIN_B1, rcv=PIN_B2, FORCE_SW) //manejo del RS232
#define RTC_SCLK PIN_A1 //definimos pin"s...
#define RTC_IO PIN_A2
#define RTC_RST PIN_A0 //...de conexion de la rtc ds1302
#include <ds1302.c> //libreria de rtc ds1302
///VARIABLES GLOBALES
byte day,mth,year,dow,hour,min,sec; //variabes para ds1302
byte menu=0,flag=0,var=2; //variables para menu configurar
///DEFINICION DE FUNCIONES
void configurar(void);
void horas(void);
void minutos(void);
void dia(void);
void mes(void);
void anio(void);
void beep(void);

#INT_TIMER0
void interrupcion()
{
if(flag>var){ //ya es 130ms aprox?
var--; //SI -> decremento var...
if(var==0)
var=2; //...ajuste fino de 130ms aprox
flag=0; //reset flag para contar 130ms aprox
rtc_get_date(day,mth,year,dow); //coge dia,mes,ao
rtc_get_time(hour,min,sec ); //coge hora,minuto,segundo
printf("fFecha: %2X/%2X/%2X
Hora: %2X:%2X:%2X",day,mth,year,hour,min,sec); //lcd
}
set_timer0(0); //reset TMR0

flag++; //incremento variable flag
}
///PROGRAMA
void main(void){
enable_interrupts(INT_TIMER0); //interrupcion TIMER0 activada

setup_counters(RTCC_INTERNAL,RTCC_DIV_256); //configuracion interrupcion TMR0
rtc_init(); //inicializa rtc
puts("Reloj Calendario" );
puts("VsZeNeR"05" );
delay_ms(800); //...inicial
configurar(); //ve a menu configurar

for( ; ; ){ //bucle...
if(input(PIN_A5)==0){ //Si se pulsa Conf....
while(!input(PIN_A5)){} //elimina rebotes
beep();
configurar();
} //ve a menu configurar
} //...infinito
}
///FUNCION CONFIGURAR
void configurar(void){
disable_interrupts(GLOBAL); //desactivadas interrupciones
do{
switch(menu){
case 0: printf("fConfigurar
horas?" ); //horas
if(!input(PIN_A5)){
while(!input(PIN_A5)){}
beep();
horas();
menu=1; //apunta siguiente opcion
flag=1; //para el retorno funcion ver sig
}
break;
minutos?" ); //minutos
if(!input(PIN_A5)){
beep();
minutos();
}
break;
dia?" ); //dias
if(!input(PIN_A5)){
beep();
dia();
}
break;
mes?" ); //mes
if(!input(PIN_A5)){
beep();
mes();
}
break;
ao?" ); //aos
if(!input(PIN_A5)){
beep();
anio();
}
break;
case 5: printf("fSalir
configurar?" ); //salir configuracion
if(!input(PIN_A5)){
menu=6;
flag=1;
beep();
}
}
do{ //controla pulsador...

if(!input(PIN_A3)){
menu++;
flag++;
if(menu>5)
menu=0;
}
if(!input(PIN_A5)) //controla pulsador...
flag++; //..."Conf/Ok"
}while(!flag); //.."Up"
flag=0;
}while(menu<6);
menu=0; //actualiza indices menu

rtc_set_datetime(day,mth,year,dow,hour,min); //nueva hora,minuto,...
}
///FUNCION CONFIGURA HORAS
void horas(void){
printf("fConf.Horas:
Hora: %2X:%2X:%2X",hour,min,sec); //muestra por v.terminal
do{
if(!input(PIN_A3)){ //se ha pulsado up?
hour++; //SI -> incremento hour
switch(hour){ //limites...
case 0x0A: hour=0x10;break;
case 0x1A: hour=0x20;break;
case 0x24: hour=0x00;
} //...hour
printf("
}
}while(input(PIN_A5));
}
///FUNCION CONFIGURA MINUTOS
void minutos(void){
printf("fConf.Minutos:
do{
min++; //SI -> incremento min
switch(min){ //limites...
case 0x0A: min=0x10;break;
case 0x5A: min=0x00;
} //...min
printf("
}
}
///FUNCION CONFIGURA DIAS
void dia(void){
printf("fConf.Dias:
Fecha: %2X/%2X/%2X",day,mth,year); //muestra por v.terminal
do{
day++; //SI -> incremento day
switch(day){ //limites...
case 0x0A: day=0x10;break;
case 0x32: day=0x01;
} //...day
printf("fConf.Dias:
}
}
///FUNCION CONFIGURA MES
void mes(void){
printf("fConf.Mes:
do{
mth++; //SI -> incremento mth
switch(mth){ //limites...
case 0x0A: mth=0x10;break;
case 0x13: mth=0x01;
} //...mth
printf("fConf.Mes:
}
}
///FUNCION CONFIGURA AOS
void anio(void){
printf("fConf.Ao:
do{
year++; //SI -> incremento mth
switch(year){ //limites...
case 0x0A: year=0x10;break;
case 0x9A: year=0x00;
} //...year
printf("fConf.Ao:
}
}
///FUNCION BEEP
void beep(void){
output_high(PIN_B3); //activa zumbador
delay_ms(50);
output_low(PIN_B3); //desactiva zumbador
}
14. Termmetro Digital con ds1620.
// Programa: Termometro digital mediante el ds1620
// Version: 1.0
//
//
// Notas: Este programa muestra por el hyperterminal la temperatura leida
// del dispositivo ds1620.
//
// Conexiones: A0 -> DQ ds1620
// A1 -> CLK/CONV# ds1620
// A2 -> RST# ds1620
//////////////////////////////////////////////////////////////////////////////////

#fuses INTRC //oscilador interno
#use rs232(baud=9600,xmit=PIN_B2,rcv=PIN_B1) //manejo del RS232
#define DS1620_DQ PIN_A0 //declaracion...
#define DS1620_CLK PIN_A1
#define DS1620_RST PIN_A2 //...de pines para el ds1620
#include <vs_ds1620.c> //libreria ds1620

#INT_TIMER1
void interrupcion() //leemos la temp y la enviamos via serial rs232 al hyperterminal
{
printf("\fVsZeNeR'06 -> Termometro Digital\n\r\n\rTemperatura: %3.1f
C",read_ds1620());
}
///PROGRAMA
void main(void)
{
setup_oscillator(OSC_4MHZ); //configuracion
del oscilador interno a 4MHz
enable_interrupts(INT_TIMER1); //interrupcion TIMER1
activada
SETUP_TIMER_1(T1_INTERNAL|T1_DIV_BY_8); //configuracion
interrupcion TMR1
set_timer1(10); //carga
TMR1
enable_interrupts(GLOBAL); //activadas
interrupciones
setup_uart(TRUE);
//activamos la uart
for(;;){} //bucle infinito -> espera interrupcion del TMR1
}

Practicas 1

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

Practicas 1

Cargado por

Copyright:

Formatos disponibles

17/03/2

JOSE ANTONIO LINERO MADRID

2. Parpadeo de tres led cada 0.5 seg.

3. Parpadeo de cuatro led cada 0.5 seg.

4. Coche fantstico v1.

8. Sper contador 0000a9999 (7 seg.)

9. Dado digital (7 seg).

10. Hola Mundo (Lcd).

11. Abecedario (Lcd).

12. Dado digital (Lcd).

13. Reloj-Calendario Rs232.

14. Termmetro Digital con ds1620.

//Programa: Parpadeo de un led cada 0.5s

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

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

RB1=0; //valor inicial B1 para que los led"s se iluminen igual

output_low(PIN_B0); //led"s off

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

RB1=0; //valor inicial B1 para que los led"s se iluminen igual

output_low(PIN_B0); //led"s off

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

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

set_tris_b(0x00); //portb como salida

for(i=0;i<4;i++){ //led"s on fuera-dentro

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

set_tris_b(0x00); //portb como salida

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

output_b(tabBCD[i]); //inicializa displayBCD digito 0

#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_a(0xFF); //porta como entrada

srand(10); //maximo hasta 9

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

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

lcd_init(); //inicializa lcd

if(x>15) //ya esta completa la 1 fila del lcd?

printf(lcd_putc,"%c",abecedario[ x ]); //muestra por pantalla el caracter

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

set_tris_a(0xFF); //porta como entrada

lcd_init(); //inicializa lcd

srand(10); //maximo hasta 9

while(input(PIN_A0)){} //Se mantiene cabecera hasta que se pulse el boton

printf(lcd_putc,"%d",num); //muestra por lcd numero

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

///LLAMADA FUNCION INTERRUPCION

set_timer0(0); //reset TMR0

enable_interrupts(INT_TIMER0); //interrupcion TIMER0 activada

rtc_init(); //inicializa rtc

configurar(); //ve a menu configurar

do{ //controla pulsador...

menu=0; //actualiza indices menu

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

///LLAMADA FUNCION INTERRUPCION

También podría gustarte