Ejercicio 1:

Crear una aplicación de control remoto en C, en la cual se tiene un teclado

matricial y si se presiona las teclas del 1 al 9 un LED parpadeará durante un
segundo con una frecuencia aproximada de 32 KHz y ciclo de trabajo de 10%,
20%, etc., dependiendo de la tecla presionada.
Código

#include <16f877.h>// Pic a utilizar

#use delay(clock=4000000) // Cristal a utilizar
#fuses xt, nowdt, noprotect // Fusibles
#byte portb=0x6// Declaro el puerto B en su localidad

#include <kbd_lib.c>
#include <lcd.c>
#byte kbd_port_d = 0x08

void main()
{
int k;

kbd_init();
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_ccp1(CCP_PWM);
set_pwm1_duty(127);

while (TRUE){

k=kbd_getc();
if(k!=0)
{
if(k=='*') k=53;
if(k=='#') k=58;
k=k-48;
k=k*25.5;

set_pwm1_duty(k);
}
}

}
Simulación
Ejercicio 2:
Implementar un programa de lectura de datos analógicos, en la cual al presionar
un botón el PIC inicie la lectura de datos analógicos, almacenando 10 muestras y
que presente en un terminal los datos (en valor decimal), su media y desviación
estándar.
Diagrama de Flujo

Código
#include <16f877A.h> //pic a utilizar
#device adc=10
#fuses XT, NOWDT // conversor ADC de 10 bits
#use delay (clock=4000000) //Fosc=4Mhz
#use rs232(baud=9600,xmit=pin_c6,rcv=pin_c7, bits=8, parity=N) //manejo del RS232
#include<lcd.c> //libreria manejo lcd
#include "math.h"
2
float dato,media,std;
int ind,media2,std2,dato2;

#int_EXT
void EXT_isr(void)
{

ind=0;
}
void main(void)
{
int i;
ind=1;
setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_INTERNAL);
enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);
lcd_init();
while(true)
{
while(ind){}
media=0;
for(i=0;i<10;i++){
set_adc_channel (0);
delay_us (20);
dato=read_adc ();
dato=(dato*(0.0048875));
dato2=dato;
write_eeprom (i, dato2);
media=media+dato2;
delay_ms(50);
}
media=media/10;
std=0;
for(i=0;i<10;i++){
dato=read_eeprom (i);

dato=dato-media;
dato=dato*dato;
std=std+dato;
}
std=std/9;
std=sqrt(std);
printf(lcd_putc, "\fmedia = %f", media);
printf("media = %f\r", media);
lcd_gotoxy(1,2);
printf(lcd_putc, "desv.std = %f", std);
printf("desviacion estandar = %f \r", std);
ind=1;
}
}

Simulación

3
Ejercicio 3:
Realizar los programas correspondientes en dos PICs, uno de los cuales
realizará la lectura analógica de un sensor de temperatura y transmitirá los datos
a al segundo PIC, el cual los almacenará en su memoria flash. Después de
almacenar 10 datos, deberá encender un LED indicando que se ha finalizado la
operación.

Diagrama de Flujo

4
 Código

PIC 1
#include <16f877A.h> //pic a utilizar
#fuses XT, NOWDT //ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz
#use rs232(baud=9600,xmit=pin_c6,rcv=pin_c7, bits=8, parity=N) //manejo del RS232
#include <stdlib.h>
#byte port_b=6 // declaramos el puerto b en su localidad
char cadena[2]; //Guardará el string recibido
int i,temper,cont,data;
int a=0; //Número de caracteres del string //Dato recibido en formato
float

#int_RDA //Interrupción por recepción de datos

void RDA_isr(){
for(cont=0;cont<=19;cont++){
cadena[i]=getc(); //Recepción del string
++i; //Preparación para recibir el siguiente caracter
if (i==2) { //Todos los caracteres recibidos
i=0; //Preparación para recibir el siguiente string
temper = atol(cadena); //Paso del string a su valor float
write_program_eeprom(a,temper);
data = read_program_eeprom(a);
printf("\n %d \n",data);
}
if (a>=19) // preguntamos si RA0 es cero
{
port_b=0b00000001; // cuando se cierra el pulsador ejecuta esta tarea
}
else if (a<19) {
port_b=0b00000000;
}
a++;
}
while(TRUE){}
}

5
void main ()
{
set_tris_b(0b00000000); // programamos el puerto b para q sea salida
enable_interrupts(GLOBAL);
enable_interrupts(INT_RDA);
}

PIC 2

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

#device adc=10 // conversor ADC de 10 bits
#fuses XT, NOWDT //ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz
#use rs232(baud=9600,xmit=pin_c6,rcv=pin_c7, bits=8, parity=N) //manejo del RS232
void main(void)
{
float medicion,temper;
char string[2]; //Guarda el valor float como string
int i=0; //Número de caracteres del string
setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_INTERNAL);
while(true)
{
set_adc_channel (0);
delay_us (20);
medicion=read_adc ();
temper=(medicion*(0.48875));
sprintf(string,"%f",temper); //Paso a string el valor float
//Envío por RS232 del valor float como string
for (i=0;i<=1;++i){
putc(string[i]);
delay_ms(150);
}
}
}

Simulación

6
Ejercicio 4:
Realizar una aplicación para el control de un motor, en la cual el PIC leerá la
entrada analógica producida por un potenciómetro, controlará la potencia
entregada a un motor DC mediante PWM (utilizando un transistor para amplificar
la señal) con un ciclo de trabajo de 0 a 100%, dependiendo de la posición del
potenciómetro.

Diagrama de Flujo

Código
7
#include <16f877A.h> //pic a utilizar
#device adc=8
#fuses XT, NOWDT // conversor ADC de 10 bits
//ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz
#use rs232(baud=9600,xmit=pin_c6,rcv=pin_c7, bits=8, parity=N) //manejo del RS232
#include<lcd.c> //libreria manejo lcd
#include "math.h"
int dato;
void main(void)
{
setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_INTERNAL);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_ccp1(CCP_PWM);
set_pwm1_duty(127);
lcd_init();
while(true)
{
set_adc_channel (0);
delay_us (20);
dato=read_adc ();
delay_ms(50);
set_pwm1_duty(dato);
}
}

Simulación

Ejercicio 5:
Implementar una aplicación de un semáforo utilizando las interrupciones de los
timers, en la cual el PIC encienda y apague 3 LEDs en un ciclo similar al de un
semáforo, con una duración de 5 segundos en rojo, 1 en amarillo y 5 en verde.
Además, deberá mostrar en un display de 7 segmentos la cuenta regresiva para
el cambio de rojo a verde (6 segundos), de manera similar a un semáforo
peatonal.
8
 Diagrama de Flujo

Código

#include <16f877.h>// Pic a utilizar

#use delay(clock=4000000) // Cristal a utilizar
#fuses xt, nowdt, noprotect // Fusibles
#byte port_B = 0x06
#byte port_D = 0x08
int cont,cont1,cont2;
#int_TIMER1
void TIMER1_isr(void)
{
set_timer1(0x0BDC);
cont1++;
cont2=cont1/2;

switch (cont2){
case 0:
port_D = 0x01;
cont=6;
break;
case 5:
port_D = 0x02;
break;
case 6:
port_D = 0x04;
break;
9
 case 11:
cont1=0;
cont2=0;

break;
default:
}
if (cont!=0){
cont=6-cont2;
}
}
void main()
{
set_tris_b(0x00);
set_tris_d(0xF8);
setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
enable_interrupts(INT_TIMER1);
enable_interrupts(GLOBAL);
cont=6;
cont1=0;
cont2=0;
port_B = 0x00;
port_D = 0x01;
while(TRUE){
switch (cont){
case 0:
port_B= 0x3F;
break;
case 1:
port_B= 0x06;
break;
case 2:
port_B= 0x5B;
break;
case 3:
port_B= 0x4F;
break;
case 4:
port_B= 0x66;
break;
case 5:
port_B= 0x6D;
break;
case 6:
port_B = 0x7D;
break;
case 7:
port_B = 0x07;
break;
case 8:
break;
case 9:
break;
default:
}
}
}

Simulación

10
Ejercicio 6:
Diseñar un controlador de temperatura simple, en el cual se tiene un sensor de
temperatura LM35 realizando lecturas constantemente. Si la temperatura baja de
25°C, se encenderá un foco incandescente (representado por un LED) con PWM
y un ciclo de trabajo de 50%, subiendo a 100% si la temperatura baja de los
20°C. Por otro lado, si la temperatura sube de los 30°C se encenderá un
ventilador (representado con un motor) con ciclo de trabajo 50%, y 100% para
temperaturas que sobrepasen los 35°C.

11
 Diagrama de Flujo

Código

#include "16f877.h"
#device adc=10//Usa resolución de 10 bits
#use delay(clock=4000000)
#fuses xt, nowdt, noput, nobrownout, nolvp, noprotect
void main (void){
float temper, medicion;
setup_ccp1(CCP_PWM);
setup_ccp2(CCP_PWM);
set_pwm1_duty(0);
set_pwm2_duty(0);
setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_INTERNAL);
while (TRUE){
set_adc_channel (0);// Elige canal a medir RA0
delay_us (20);
medicion=read_adc (); // Hace conversión AD
delay_ms(50);
temper=medicion*(0.48875); // Pasa binario a °C
if(temper<=20){
set_pwm1_duty(255);
}else if(temper<=25){
set_pwm1_duty(127);

12
 }
if(temper>=35){
set_pwm2_duty(255);
}else if(temper>=30){
set_pwm2_duty(127);
}
if(temper>25&&temper<30){
set_pwm1_duty(0);
set_pwm2_duty(0);
}
}
}
Simulación

13