I.T.S.S.N.P.

Instituto Tecnológico Superior de la Sierra Norte de Puebla

“Reporte de Practicas”

Integrantes:

 Alejandro Javier Pérez Aldaco.

 Dagoberto Ramírez Hernández
 Aylin Villalba Monroy
 Eduardo Pérez Munguía
 Martin Cortez
 Raúl García Guerra

Catedrático:

 Eyvar Trejo Garrido.

Materia:

 Microcontroladores

Carrera:

 Electromecánica

Periodo Escolar:

Enero - Junio del 2017

MATERIAL PARA EL CURSO:

 PROTOBOARD
 GRABADOR DE PIC´S
 TRARJETA ENTRENADORA 18f4550 con cable ubs (Microside)
 2 pic 16F628A
 3 Push Burton N/A DE 4 TERMINALES
 Módulo de 1 relevador
 Pantalla LCD 16X2
 1 Tira de pines
 10 Leds
 10 Resistencias de 330 ohms
 2 resistencias de 1K
 Display de 7 segmentos (Cátodo común)
 Preset(50K designación 503)
 Sensor de temperatura LM35
 Motor a pasos
 Teclado matricial 4x4
 1 servomotor SG90
 Cables Dupont. (Mancho – Macho, Macho –Hembra, Hembra – hembra)

Software:
 El que corresponda el grabador de pics
 El usuario por el proyecto MULTISIDE
 PIC C Compiler
 Proteus

CURSOS BÁSICOS DE MICROCONTROLADORES.

INTRODUCCION
Microcontrolador es un circuito integrado o chip que incluye en su interior las tres unidades funciones de una
computadora: CPU, memoria y unidades de E/S, es decir, se trata de un computador completo en un solo
circuito integrado. De forma más sencilla. Es una microcomputadora con la cual disponemos de todo, en
pequeñas cantidades, para hacer uso en aplicaciones que requieran automatización, sin la necesidad de tener
toda una computadora función.
En los microcontroladores la memoria no es abundante, no hay Gigabytes de memoria como las computadoras
personales. Normalmente la memoria de programas no excederá de 16k-localizaciones de memoria no volátil
(flash o eprom) para contener los programas.
 RAM: volátil y guarda información mientras entre energizada.
 ROM: memoria de solo lectura.
 PROM: memoria de solo lectura, programable.
 EMPROM: memoria de solo lectura, programable y borrable.
 EMPROM o 𝐸 2 PROM: memoria de solo lectura, programable y borrable electrónicas.
 FLASH: memorias re-escribible.(USB)
El microntrolador contiene puertos que pueden ser de tipo:
 Entrada
 Salida
 Bidireccionales
El puerto se maneja como si fuera una localidad de memoria, se mandan o reciben datos a través de los pines
del microcontrolador.
Un microntrolador (abreviando µc, UC o MCU) es un circuito integrado programable, capaz de ejecutar las
órdenes grabadas en su memoria.
Está compuesto de varios bloques funcionales, los cuales cumplen una tarea específica. Un microcontrolador
incluye en su
 Interior las tres principales unidades funcionales de una computadora; unidades central de procesamiento,
memoria y periféricos entrada/salida.
Algunos microcontroladores pueden utilizar palabras de cuatro bist y funcionan a velocidad de reloj con
frecuencias tan bajas como 4 KHZ, con un consumo de baja potencia (mw o microvatios.) Por lo general, tendrá
la capacidad de mantenerse a la espera de un evento como pulsar un botón o de interrupción; así, el consumo
de energía durante el estado de reposo (reloj de la CPU y los periféricos de la mayoría) puede ser solo de
nanovatios, lo que hace que muchos de ellos sean muy adecuados para aplicaciones con baterías de larga
duración. Otros microcontroladores pueden servir para roles de rendimiento crítico, donde sea necesario actuar
más como un procesador digital de señal (DSP), con velocidades de reloj y consumo de energía más alto.
Cuando es fabricado el microcontrolador, no contiene datos en la memoria ROM. Para que pueda controlar algún
proceso es necesario generar o crear y luego grabar en la EEPROM o equivalente del microcontrolador algún
programa, el cual puede ser escrito en lenguaje ensamblador u otro lenguaje para microcontroladores: sin
embargo, para que el programa pueda ser grabado en la memoria del microcontrolador, debe ser codificado en
un sistema numérico hexadecimal que es finalmente el sistema que hace trabajar al microcontrolador cuando
éste es alimentado con el voltaje adecuado y asociado a dispositivos analógicos y discretos para su
funcionamiento.
La familia de microcontroladores PIC (de 8- bits) se divide en las siguientes gamas:
 Gama baja (12-Bit opcode). PIC10 ( y algunos PIC12 y PIC16) La características principal sería la simplicidad.
Pila implementada en hardware, con solo, 2 niveles. Puede manejar solamente hasta 32 registros (RAM) y 512
palabras de instrucción.
 Gama media (14-Bit opcode). PIC12 y PIC16 se ofrece en tamaño de 8 a 68 pines. Se agrega la capacidad de
manejo de interrupciones
Y 8 nieles de pila hardware. Puede manejar hasta 128 registros (RAM) y 2048 palabras de instrucción.
 Gama alta (14-Bit opcode). PIC17 (obsoleto) y PIC18 Manejo vectorial de interrupciones. Nuevas instrucciones
optimizadas para la programación lenguajes de alto nivel. Pila de hasta 31 niveles.

1.1 El compilador CCS

El compilador C de CCS ha sido desarrollado específicamente para PIC MCU, obtenido la máxima
optimización del compilador con estos dispositivos. Dispone de una amplia librería de funciones
predefinidas, comandos de preprocesador y ejemplos. Además, suministra los microcontroladores (drivers)
para diversos dispositivos como LCD, convertidores AD, relojes en tiempo real, EEPROM seria etc. Las
características generales de este compilador y más información adicional se pueden encontrar en la
dirección http://www.ccsinfo.com
Un compilador convierte el lenguaje de alto nivel a instrucciones en código máquinas; cross- compiler es un
compilador que funciona en un procesador (normalmente en un PC) diferente al procesador objeto. El
compilador CCS C es un s maquinas en el entorno de trabajo del PC, el código máquinas puede ser cargado
del PC al depurado PIC mediante el ICD2(o mediante cualquier programador) y puede ser depurado (puntos
de ruptura, paso a paso, etc.) desde el entorno de trabajo de PC.
cros-compiler. Los programas son editados y compilados a instruccioneEl CCS C estándar y, a además de
las directas estándar /#include, etc.), suministra una directas específicas para PIC(#device, etc.);además
incluye funciones específicas (bit _set(),etc).Se sumistra con un editor que permite controlar la sintaxis del
programa.
Nota:
En el manual de CCS se da muchas más información de la que a continuación se va dar. En este capítulo
sólo se describirán los elementos más básicos y esenciales para comenzar a programar.

1.1.1 estructura de un programa

Para escribir un programa en C con el CCS C se deben tener en cuenta una serie de elementos básicos
de su estructura.

 DIRECTIVAS DE PREPROCESADO: Controlan la conversión del programa a código máquinas

por parte del compilador.
  PROGRAMAS O FUNCIONES: conjunto de instrucciones. Puede haber uno o varios; en
cualquier caso siempre debe haber uno definido como principal mediante la inclusión de la
llamada main().
 INSTRUCCIONES: Indican como debe comportar el PIC en todo momento.
 COMENTARIOS: permiten describir lo que significa cada línea del programa.

1.1.2 Diagrama de flujo.

Los diagramas del flujo son una herramienta que permite representar visualmente que operaciones se
requieren y en que secuencias se deben efectuar para solucionar un problema dado. Por consiguiente,
un diagrama de flujo es la representación gráfica mediante símbolos especiales, de los pasos o
procedimientos de manera secuencial y lógica que se deben realizar para solucionar un problema dado.
Los diagramas del flujo desempeñan un papel vital en la programación de un problema, ya que facilitan
la compresión de problemas complicados y sobre todo aquello en que sus procesos son muy largos; 2
generalmente los diagramas de flujo se dibujan antes que comenzar a programa el código fuente, que se
ingresará posteriormente a la computadora. Los diagramas de flujo facilitan la comunidad entre los
programadores y los usuarios, además de que permiten de una manera más rápida detectar los posibles
errores de lógica que se presentan al implementar el algoritmo.

Dentro de los diagramas de flujo se pueden utilizar los símbolos que se presentan en la sig. Tabla, con
los cuales se indican las operaciones que se efectuarán a los datos con el fin de producir un resultado.

Símbolos significado
Terminal/inicio

Entrada da datos.

proceso

decisión

Decisión múltiple.

Imprimir resultado.

Flujo de datos.

Conectores.

Por ejemplo, se puede establecer la solución del diagrama de flujo para

determinar el volumen de una caja de dimensiones A, B Y C como se
muestra la sig. Figura.
Inicio
incio
Leer la medidas
A,B, y C

A,B,C
incio
Calcular el
volumen
VOLUMEN=A*B*C C

Escribir el
volumen VOLUMEN
obteniendo.

INICIO
Fin del proceso.

Como se puede ver manera gráfica, se establece de forma precisa la

secuencia de los pasos por realizar para obtener el resultado del volumen.
Como se puede graficar, son los mismos que se establecieron que se
establecer en el algoritmo presentado previamente mediante el pro
seudocódigo.
1.1.3 Tipos de datos

CCS C aceptar los siguientes tipos de datos.

Tipo Tamaño Rango Descripcion
Intl 1 bit 0a1 Entero de 1 bit
Short
Int Int8 8 bit 0 a 255 Entero
Int16 Long 16 bit 0 a 65.535 Entero de 16 bit
Int32 32 bit 0 a Entero de 32 bit
4,294,967.295
Float 32 bit +1.175x10−38 a Coma flotante
+3.402x10−38
Char 8bit 0 a 255 caracter
Void - - Sin valor
igned Int8 8bit -128 a +127 Entero con signo
Signed Int16 16bit -32768 a+ Entero largo con
32767 signo
Signed Int32 32bit −231 a+ (231 -1) Entero 32 bit
con signo

1.1.4 Las constantes

Las contantes se pueden especificar en decimal, octal, hexadecimal o en
binario;
123 decimal
0123 Octal(0)
0x123 Hexadecimal(0x)
0b010010 Binario(0b)
´x´ carácter
´/010’ Carácter octal
‘/xA5´ Carácter hexadecimal
Además, se puede definir constante con un sufijo:
Int8 127U
Long 80UL
Signed INT16 80L
Float 3.14f
Chart Con comillas simples ”C”

También se define características especiales algunos como:

/n Cambio de linea
/r Retorno de carro
/t tabulacion
/b backspace
1.1.5 variables
Las variables se utilizan para nombre posiciones de memoria RAM; se deben
declarar, obligatoriamente, antes de utilizar; para ello se debe indicar el
nombre y el tipo de dato que se manejará. Será definen de la siente forma:
TIPO NOMBRE VARIABLE [=VALOR INICIAL]
TIPO hace referencia a cualquiera de los tipos de datos vistos en el punto
2.3.El nombre variable puede ser cualquiera y el valor inicial es opcional
vamos ejemplo:

Float temp_LIMIT=500,0;
Las variables define en un programa pueden ser de tipo local o global. Las
variables locales solo se utilizan en la función donde se encuentran declarad
variable global se pueden utilizar en todas las funciones del programa.
Ambas deben declararse antes de ser utilizadas y las globales deben
declararse antes de cualquier función y fuerza de ellas. Las variables
globales son puestas a cero cuando se inicia la función principal main().
#include <16f876.h>
#USE DELAY (CLOCK=4000000)
Int16 counter; //variable global
Void function(void)
(
Char K, kant=´0´; //variable locales
)
Void main()
(
Int0 temp; //variable local
)
Las variables pueden ser definidas con:

Auto : (usada por defecto, no hace falta que se indique donde la variable
existe mientras la función esta activa. Estas variables no se inicializan a cero.
Su valor se piede cuando se sale de la función.
Static: una variable local se activa como global , se inicializa a cero y
manteniendo su valor al entrada y salida de la función.
Exten : permite el uso de variables en compilaciones multiples.
1.1.6 operadores
1.1.6.1 asignacion
+= Asignación de suma
(x+=y lo mismo que
x=x+y)
-= Asignación de resta (x-=y
lo mismo que x=x-y)
+= Asignación de
multiplicación (x*=y lo
mismo que x=x*y)
/= Asignación de division
(x/=y lo mismo que x=x/y)
%= Asignación del resto de la
 division(x%=y lo mismo
que x=x%y)
<<= Asignación de
desplazamiento a la
izquierda (x<<=y lo mismo
que x=x<<y)
>>= Asignación de
desplazamiento a derecha
(x>>=y es igual que
x=x>>y)
&= Asignación ADN de bits
(x&=y es lo mismo que
x=x&y)
I= Asignación OR de bits
(xI=y es lo mismo que
x=xIy)
^= Asignacion OR
EXCLUSIVA de bits (x^=y
es lo mismo que x=x^y)

1.1.6.2 Aritmeticos

+ Suma
- Resta
* Multiplicación
/ division
% Modulo, resto de una
división entera
-- Incremento
++ Decremento
Sizeof Determina el tamaño, en
bytes, de un operando

En las operaciones de decremento e incremento, en función de la posición

del operador, se consigue un preincremento (++A) o un postincremento (A++)
a=3 ;
b=4*a++ ; // b-4 y a=4;

a=3
b=4*++3 ; // b=16 y a=4 ;

1.1.6.3 Relacionales
< Menor que
> Mayor que
>= Mayor o igual que
<= Menor igual que
== Igual
!= Distinto
?: Expresión condicional

1.1.6.4 Logicos
! NOT
&& AND
II OR

1.1.6.5 De bits
~ Complemento a 1
& AND
^ OR EXCLUSIVA
I OR
 >> Desplazamiento a derechas
<< Desplazamiento a izquierdas

1.1.6.6 De punteros
& Dirección
* Indirección
-> Puntero a estructura

Orden de precedencia de los operadores:

Expresiones en orden de precedencia descendente

(expr)
!expr ~expr ++expr Expr++ --expr expr
(type)expr *expr &value Sizeof(type)
Expr*expr Expr/expr Expr%expr
Expr+expr Expr-expr
Expr<<expr Expr>>expr
Expr<expr Expr<=expr Expr>expr Expr>=expr
Expr==expr Expr!=expr
Expr&expr
Expr^expr
Expr I expr
Expr&&expr
Expr I I expr
Expr?expr:expr
Ivalue=expr Ivalue+=expr Ivalue-=expr
Ivalue*=expr Ivalue/=expr Ivalue%=expr
Ivalue>>=expr Ivalue<<=expr Ivalue&=epr
Ivalue^=expr Ivalue!=expr Expr,expr
1.1.7 Funciones
Las funciones son bloques de sentencias; todas las sentencias se deben enmarcar dentro de las
funciones. Al igual que las variables, las funciones deben definirse antes de utilizarse.
Una función puede ser invocada desde una sentencia de otra función. Una función puede
devolver un valor a la sentencia que la ha llamado. El tipo de dato se indica en la definición de la
función; en el caso de no indicarse nada se entiende que es un int8 y en el caso de no devolver
un valor se debe especificar el valor VOID. La función, además de devolver un valor, puede
recibir parámetros o argumentos.
Las estructuras de una función es:
ripo_pato Nombre-funcion (tipo paraml, param2,…)
(
(sentencias);
)

Float traunca (float a)i

Float b;
b-floor)a);
a-ab;
a-a*100;
a-floor)a);
a-a+0-03;
a-b+a;
return(a);
)
La forma de devolver un valor es mediante la sentencia RETURN:
Return (expresión):
Return expresión:
 Donde expresión debe manejar el mismo tipo de dato que el indicado en la definición de la
función. En el caso de no devolver nada se finaliza con RETURN, al encontrar esta sentencia el
compilador vuelve a la ejecución de la sentencia de llamada. Tambien se puede finalizar la
función sin RETURN, tan solo con la llave de cierre “J”.
La funciones pueden agruparse en ficheros de librerías <fichero.h>, que se pueden utilizar
mediante la directa #include>fichero.h.>
1.1.8 DECLARANCIONES DE CONTROL.
Las declaraciones son usadas para controlar el proceso de ejecución del programa.
Las que admite CCS son:
 If-Else.
 While
 Do-While
 Flor
 Switch-case.
 Return
 Break,Continue y Gato

1.1.8.1. IF-ELSE

Con la ayuda de IF-ELSE se pueden tomar decisiones.

If 7(EXPRECION)

Sentencia_2;

LELSE

Sentencia_2;

Nota

Los elementos que se encuentran entre corchetes [] son opcionales.

Primeros se evalúa la expresión y si cierta (TRUE o1) ejecuta la sentencia_I, en el caso contrario (FALSE o D) ejecutar la
SENTENCIA_2.

Pueden anidarse los IF-ELSE dado el lugar a los IF-ELSE; esto permite tomer decisiones múltiples.

if (exprecion_1)

Sentencia_1;

Lelse if (expresión_2)

Sentencia_2;3

Lelse

Sentencia_3;3

En este caso la expresión se evalúa en orden, si alguna de ellas es cierta la SENTENCIA asociada a ella se ejecutaran y
se termina la función. En caso contrario se ejecuta la SENTENCIA de ELSE. En ambos casos si existen varias
sentencias para ejecutar se deben utilizar las llaves[]

if (exprecion)

)
 Sentencia_1;

…….

Sentencia_n;

Lelse

Sentencia_1;

………

Sentencia_n;

))

Ejemplos

Ca5
B=10 SI no
A=0?

IF(A==0) B=10; ELSE C=5;

IF(A!=1) B=10; ELSE C=5;

 IF(A>10)
IF(A>20)B=5; ELSE
C=15;

A>10? SI

A>20? NO
SI

B+5 B+15

IF(A>10) {IF(A>20)B=15;
ELSE C=5;

A>10? SI

NO
A>20? SI
NO

B=5 B=15
1.1.8.2 SWITCH

Switch en un caso particular de una decían multiple

Switch (expresión)

Case constante1:

Sentencia;

Breack;

Case constante2:

Sentencia;

Breack;

…..

[defaul:

Sentencia;]

Evalúa la expresión y en orden a la CONTANTE adecuado las sentencias asociadas. Si ninguno de los CASE
corresponda a la CONTANTE se ejecuta DEFAULT (este comité es opcional). El comando BREAK provoca la salida de
SWITCH, de lo contrario se ejecuta el siguiente CASE. Nota: No pueden existir dos CASE con la misma CONTANTE.
 A>0?
A>20?
SI B=1
Switch
(A)(case
0:B=1:

Break;
NO
Case2;
B=2:

Break;
A=2? B=2
SI
Case3:

B=3;

Break;
NO
Default:
breaj; }

A=3? SI B=3

NO

1.1.8.3 FOR

Se usa para repetir sentencia.

For (inicialización: condición de finalización ; incremento)

Sentencias

En las expresiones de FOR la inicialización es una variabilidad la cual se le asigna un valor inicial inicial con el que
controlar el bucle. La condición de finalización sirve para evaluar ANTES de ejecutar las sentencias si es cierta o no, en
el caso de ser cierta se ejecutan la sentencia y en caso contrario se sale del FOR. Por ultimo de incremento o
decremento modifica la variable de control DESPUES de ejecutar el bucle.
Nota

Se puedan anidar bucles FOR utilizando distintas variables de control.

Si se ejecuta la siguiente expresión se consigue un BUCLE SIN FIN:

For (;;)

Sentencias;

Ejemplo:
FOR (N=1;N<10,N++
N=1 {

Printf(“%U”,N);

N<=10

si
NO

IMPRIMIR N N=N+1

1.1.8..4 WHILE/DO-WHILE

WHILE se utiliza para repetir sentencia

While (expresión)

Sentencia;

La expresión se evalúa y la sentencia se ejecuta mientras las expresiones es verdadera, cuando es falsa se sale del
WHILE.
DO-WHILE se diferencia de WHILE y del FOR en la condición de finalización la cual se evalúa al final de bucle, por lo
que las sentencias se ejecutan al menos una vez.

Do

Sentencias;

While (expresión);

Si se ejecutan las siguientes expresiones se consigue un BLUCLE SIN FIN:

While(1)

Sentencia;

Do

Sentencias;

While (1)

While(N>
N<=10
Escriba aquí la ecuación.

PRACTICA #1
Encender y apagar un led

Entrenadora
PIC16f628A
#include <16f628a.h> #include <18f4550.h>
#FUSES NOWDT #fuses XT
#FUSES INTRC_IO #fuses NOWDT
#FUSES NOPUT #fuses NOBROWNOUT
#FUSES NOPROTECT #fuses NOPROTECT
#FUSES NOBROWNOUT #fuses NOLVP
#FUSES NOMCLR #fuses NODEBUG
#FUSES NOLVP #fuses USBDIV
#FUSES NOCPD #fuses PLL5
#use delay(clock=4000000) #fuses CPUDIV1
#fuses VREGEN
void main() #fuses MCLR
{ #fuses NOPBADEN
while(true) #fuses WRTB
{ #fuses CPB
output_bit(pin_b0,0); #use delay(clock=48000000)
delay_ms(2000); #build(reset=0x2000,interrupt=0x2008)
output_bit(pin_b0,1); #org 0x0000,0x1FFF{}
delay_ms(2000)
} //--------------------------------------------
} void main()
{
while(true)
{
output_bit(pin_b0,0);
delay_ms(2000);
output_bit(pin_b0,1);
delay_ms(2000)
}
}

En esta imagen se muestra el circuito elaborado en

Proteus en la cual utilizamos el PIC16f628A y lo
colocamos con una resistencia de 330 ῼ a la salida
del PIC que esta marcado con el numero 6 y
después de la resistencia se coloca el led y del led
a tierra y así una vez armado el circuito se coloca
la información de la programación del Pic que se
hizo en compiler y el led tiene que encender.

PRACTICA #2
Encender 3 leds

Entrenadora
PIC16f628A
 #include<16f628a.h>
#FUSES NOWDT #include <18f4550.h>
#FUSES INTRC_IO #fuses XT
#FUSES NOPUT #fuses NOWDT
#FUSES NOPROTECT #fuses NOBROWNOUT
#FUSES NOBROWNOUT #fuses NOPROTECT
#FUSES NOMCLR #fuses NOLVP
#FUSES NOLVP #fuses NODEBUG
#FUSES NOCPD #fuses USBDIV
#use delay(clock=4000000) #fuses PLL5
#fuses CPUDIV1
void main() #fuses VREGEN
{ #fuses MCLR
{ #fuses NOPBADEN
output_bit(pin_b0,0); #fuses WRTB
delay_ms(1000); #fuses CPB
output_bit(pin_b0,1); #use delay(clock=48000000)
delay_ms(2000); #build(reset=0x2000,interrupt=0x2008)
output_bit(pin_b1,1); #org 0x0000,0x1FFF{}
delay_ms(3000);
output_bit(pin_b2,1); //--------------------------------------------
void main()
} {
} {
output_bit(pin_b0,0);
delay_ms(1000);
output_bit(pin_b0,1);
delay_ms(2000);
output_bit(pin_b1,1);
delay_ms(3000);
output_bit(pin_b2,1);

}
}

En esta segunda practica se utilizan los mismos

componentes antes utilizados pero en esta ocasión se
colocan tres leds para que enciendan en orden
consecutivo de 1 segundo y como se colocan tres leds
se colocan 3 resistencias que van conectados a los
pines 6,7 y 8 del PIC.

PRACTICA #3
Encender y apagar 3 leds

Entrenadora
PIC16f628A
#include <16f628a.h> #include <18f4550.h>
#FUSES NOWDT #fuses XT
#FUSES INTRC_IO #fuses NOWDT
#FUSES NOPUT #fuses NOBROWNOUT
#FUSES NOPROTECT #fuses NOPROTECT
#FUSES NOBROWNOUT #fuses NOLVP
#FUSES NOMCLR #fuses NODEBUG
#FUSES NOLVP #fuses USBDIV
#FUSES NOCPD #fuses PLL5
#use delay(clock=4000000) #fuses CPUDIV1
#fuses VREGEN
void main() #fuses MCLR
{ #fuses NOPBADEN
while(true) #fuses WRTB
{ #fuses CPB
output_bit(pin_b0,1); #use delay(clock=48000000)
delay_ms(1000); #build(reset=0x2000,interrupt=0x2008)
output_bit(pin_b0,1); #org 0x0000,0x1FFF{}
delay_ms(1000);
output_bit(pin_b0,0); //--------------------------------------------
void main()
output_bit(pin_b1,1); {
delay_ms(1000); while(true)
output_bit(pin_b1,1); {
delay_ms(1000); output_bit(pin_b0,1);
output_bit(pin_b1,0); delay_ms(1000);
output_bit(pin_b0,1);
output_bit(pin_b2,1); delay_ms(1000);
delay_ms(1000); output_bit(pin_b0,0);
output_bit(pin_b2,1);
delay_ms(1000); output_bit(pin_b1,1);
output_bit(pin_b2,0); delay_ms(1000);
output_bit(pin_b1,1);
} delay_ms(1000);
} output_bit(pin_b1,0);

output_bit(pin_b2,1);
delay_ms(1000);
output_bit(pin_b2,1);
delay_ms(1000);
output_bit(pin_b2,0);

}
}

Para la elaboración de esta tercer practica se hiso uso

del mismo circuito que la practica dos ya que lo que se
hiso fue encender los 3 leds pero con programación
diferente ya que en la practica dos una vez encendidos
los 3 se quedaban así y en esta lo que se hiso fue
encenderlos consecutivamente pero que también se
apagaran en orden y así consecutivamente se repitiera
el ciclo
 PRACTICA #4

Entrenadora
PIC16f628A

#include<18f4550.h> #include <18f4550.h>

#use delay(clock=48000000) #fuses XT
#build(reset=0x02000,interrupt=0x02008) #fuses NOWDT
#org 0x0000,0x1FFF{} #fuses NOBROWNOUT
//------------ #fuses NOPROTECT
#fuses NOLVP
void main() #fuses NODEBUG
{ #fuses USBDIV
while(true) #fuses PLL5
{ #fuses CPUDIV1
output_bit(pin_b0,1); #fuses VREGEN
delay_ms(1000); #fuses MCLR
output_bit(pin_b0,1); #fuses NOPBADEN
delay_ms(1000); #fuses WRTB
output_bit(pin_b0,0); #fuses CPB
#use delay(clock=48000000)
output_bit(pin_b1,1); #build(reset=0x2000,interrupt=0x2008)
delay_ms(1000); #org 0x0000,0x1FFF{}
output_bit(pin_b1,1);
delay_ms(1000); //--------------------------------------------
output_bit(pin_b1,0); void main()
{
output_bit(pin_b2,1); set_tris_b(0b00000000);// pin del puerto B como salida
delay_ms(1000); output_b(0b00000000);
output_bit(pin_b2,1); while(true)
delay_ms(1000); {
output_bit(pin_b2,0); output_toggle(PIN_B0);
delay_ms(2000);
} }
} }
 PRACTICA #5
Encender 8 leds

Entrenadora
PIC16f628A

#include <16f628a.h> #include <18f4550.h>

#FUSES NOWDT #fuses XT
#FUSES INTRC_IO #fuses NOWDT
#FUSES NOPUT #fuses NOBROWNOUT
#FUSES NOPROTECT #fuses NOPROTECT
#FUSES NOBROWNOUT #fuses NOLVP
#FUSES NOMCLR #fuses NODEBUG
#FUSES NOLVP #fuses USBDIV
#FUSES NOCPD #fuses PLL5
#use delay(clock=4000000) //frecuecia para trabajar #fuses CPUDIV1
con el puerto sb y del pic #fuses VREGEN
Void main() #fuses MCLR
{ #fuses NOPBADEN
set_tris_b(0b00000000); #fuses WRTB
set_tris_b(0b11110000); #fuses CPB
output_b(0b00000000); #use delay(clock=48000000)
while (true) #build(reset=0x2000,interrupt=0x2008)
{ #org 0x0000,0x1FFF{}
output_b (0b00000001);
delay_ms(200); //--------------------------------------------
output_b (0b00000011); Void main()
delay_ms(200); {
output_b (0b00000111); set_tris_b(0b00000000);
delay_ms(200); set_tris_b(0b11110000);
output_b (0b00001111); output_b(0b00000000);
delay_ms(200); while (true)
output_b (0b00011111); {
delay_ms(200); output_b (0b00000001);
output_b (0b00111111); delay_ms(200);
delay_ms(200); output_b (0b00000011);
output_b (0b01111111); delay_ms(200);
delay_ms(200); output_b (0b00000111);
output_b (0b11111111); delay_ms(200);
delay_ms(200); output_b (0b00001111);
output_b (0b00000000); delay_ms(200);
delay_ms(200); output_b (0b00011111);
} delay_ms(200);
} output_b (0b00111111);
delay_ms(200);
output_b (0b01111111);
delay_ms(200);
output_b (0b11111111);
delay_ms(200);
output_b (0b00000000);
delay_ms(200);
}
}
 PRACTICA #6
Semáforo

Entrenadora
PIC16f628A

#include <16f628a.h> #include <18f4550.h>

#FUSES NOWDT #fuses XT
#FUSES INTRC_IO #fuses NOWDT
#FUSES NOPUT #fuses NOBROWNOUT
#FUSES NOPROTECT #fuses NOPROTECT
#FUSES NOBROWNOUT #fuses NOLVP
#FUSES NOMCLR #fuses NODEBUG
#FUSES NOLVP #fuses USBDIV
#FUSES NOCPD #fuses PLL5
#use delay(clock=4000000) //frecuecia para trabajar #fuses CPUDIV1
con el puerto sb y del pic #fuses VREGEN
Void main() #fuses MCLR
{ #fuses NOPBADEN
set_tris_b(0b00000000); #fuses WRTB
set_tris_b(0b11110000); #fuses CPB
output_b(0b00000000); #use delay(clock=48000000)
while (true) #build(reset=0x2000,interrupt=0x2008)
{ #org 0x0000,0x1FFF{}
output_b (0b10000001);
delay_ms(2000); //--------------------------------------------
output_bit(pin_b6,1); Void main()
delay_ms(500); {
output_bit(pin_b6,0); set_tris_b(0b00000000);
delay_ms(500); set_tris_b(0b11110000);
output_bit(pin_b6,1); output_b(0b00000000);
delay_ms(500); while (true)
output_bit(pin_b6,0); {
output_b (0b10000001);
output_b (0b00100100); delay_ms(2000);
delay_ms(2000); output_bit(pin_b6,1);
delay_ms(500);
output_bit(pin_b1,1); output_bit(pin_b6,0);
delay_ms(500); delay_ms(500);
output_bit(pin_b1,0); output_bit(pin_b6,1);
delay_ms(500); delay_ms(500);
output_bit(pin_b1,1); output_bit(pin_b6,0);
delay_ms(500);
output_bit(pin_b1,0); output_b (0b00100100);
delay_ms(2000);
}
} output_bit(pin_b1,1);
delay_ms(500);
output_bit(pin_b1,0);
delay_ms(500);
output_bit(pin_b1,1);
delay_ms(500);
output_bit(pin_b1,0);

}
}
 PRACTICA #7
Sentencia IF

Entrenadora
PIC16f628A

#include<16f628a.h> #include <18f4550.h>

#FUSES NOWDT #fuses XT
#FUSES INTRC_IO #fuses NOWDT
#FUSES NOPUT #fuses NOBROWNOUT
#FUSES NOPROTECT #fuses NOPROTECT
#FUSES NOBROWNOUT #fuses NOLVP
#FUSES NOMCLR #fuses NODEBUG
#FUSES NOLVP #fuses USBDIV
#FUSES NOCPD #fuses PLL5
#use delay(clock=4000000) #fuses CPUDIV1
void main() #fuses VREGEN
{ #fuses MCLR
#fuses NOPBADEN
set_tris_a(0b11110000); #fuses WRTB
set_tris_b(0b00000000); #fuses CPB
#use delay(clock=48000000)
#build(reset=0x2000,interrupt=0x2008)
output_b(0b00000000); #org 0x0000,0x1FFF{}
FOR(;;)
{ //--------------------------------------------
IF(input(PIN_A0) )
{ Void main()
output_high(PIN_B0); {

} set_tris_a(0b11110000);// 1=entrada
} set_tris_b(0b00000000); // 0= salida
}

output_b(0b00000000);
FOR(;;)
{
IF(input(PIN_A0) )
{
output_high(PIN_B0);

}
}
}

PRACTICA #8
Examen unidad 1
 Entrenadora
PIC16f628A

#include <16f628a.h> #include <18f4550.h>

#FUSES NOWDT #fuses XT
#FUSES INTRC_IO #fuses NOWDT
#FUSES NOPUT #fuses NOBROWNOUT
#FUSES NOPROTECT #fuses NOPROTECT
#FUSES NOBROWNOUT #fuses NOLVP
#FUSES NOMCLR #fuses NODEBUG
#FUSES NOLVP #fuses USBDIV
#FUSES NOCPD #fuses PLL5
#use delay(clock=4000000) //frecuecia para trabajar #fuses CPUDIV1
con el puerto sb y del pic #fuses VREGEN
Void main() #fuses MCLR
{ #fuses NOPBADEN
set_tris_b(0b00000000); #fuses WRTB
set_tris_b(0b11111111); #fuses CPB
output_b(0b00000000); #use delay(clock=48000000)
while (true) #build(reset=0x2000,interrupt=0x2008)
{ #org 0x0000,0x1FFF{}
output_b (0b00000001);
delay_ms(500); //--------------------------------------------

output_b (0b00000010); Void main()

delay_ms(500); {
set_tris_b(0b00000000);
output_b (0b00000100); set_tris_b(0b11111111);
delay_ms(500); output_b(0b00000000);
while (true)
output_b (0b00001000); {
delay_ms(500); output_b (0b00000001);
delay_ms(500);
output_b (0b00010000);
delay_ms(500); output_b (0b00000010);
delay_ms(500);
output_b (0b00100000);
delay_ms(500); output_b (0b00000100);
delay_ms(500);
output_b (0b01000000);
delay_ms(500); output_b (0b00001000);
output_b (0b10000000); delay_ms(500);
delay_ms(500);
output_b (0b00010000);
delay_ms(500);
output_b (0b00100000);
output_b (0b01000000); delay_ms(500);
delay_ms(500); output_b (0b01000000);
output_b (0b00100000); delay_ms(500);
delay_ms(500); output_b (0b10000000);
output_b (0b00010000); delay_ms(500);
delay_ms(500); output_b (0b01000000);
output_b (0b00001000); delay_ms(500);
delay_ms(500); output_b (0b00100000);
output_b (0b00000100); delay_ms(500);
delay_ms(500); output_b (0b00010000);
output_b (0b00000010); delay_ms(500);
delay_ms(500); output_b (0b00001000);
delay_ms(500);
output_b (0b00000100);
} delay_ms(500);
} output_b (0b00000010);
delay_ms(500);

}
}

PRACTICA #4