HERRAMIENTAS

UN motor de doble rotación

4 leds

1 puente H

2 Protoboart

Pic

Teclado matricial 4x4

Lcd 2x16

Quarzo

5 resistencias

Cables 22agw

Potenciómetro

Fuente de energía de 12 vcc

4 sensores magnéticos

Una maqueta de 4 pisos

Programador quadx

Soporte del pic

PROGRAMAS

Proteus

Ccs

Quadx
Microcontrolador PIC

General Instrument PIC1650.

Viejos microcontroladores PIC (EPROM).

Los PIC son una familia de microcontroladores tipo RISC

fabricados por Microchip Technology Inc. y derivados del
PIC1650, originalmente desarrollado por la división de
microelectrónica de General Instrument.

El nombre actual no es un acrónimo. En realidad, el

nombre completo es PICmicro, aunque generalmente se
utiliza como Peripheral Interface Controller (controlador de interfaz periférico).

El PIC original se diseñó para ser usado con la nueva CPU de 16 bits CP16000. Siendo en general
una buena CPU, ésta tenía malas prestaciones de entrada y salida, y el PIC de 8 bits se desarrolló
en 1975 para mejorar el rendimiento del sistema quitando peso de E/S a la CPU. El PIC utilizaba
microcódigo simple almacenado en ROM para realizar estas tareas; y aunque el término no se
usaba por aquel entonces, se trata de un diseño RISC que ejecuta una instrucción cada 4 ciclos del
oscilador.

En 1985 la división de microelectrónica de General Instrument se separa como compañía

independiente que es incorporada como filial (el 14 de diciembre de 1987 cambia el nombre a
Microchip Technology y en 1989 es adquirida por un grupo de inversores) y el nuevo propietario
canceló casi todos los desarrollos, que para esas fechas la mayoría estaban obsoletos. El PIC, sin
embargo, se mejoró con EPROM para conseguir un controlador de canal programable. Hoy en día
multitud de PIC vienen con varios periféricos incluidos (módulos de comunicación serie, UART,
núcleos de control de motores, etc.) y con memoria de programa desde 512 a 32 000 palabras
(una palabra corresponde a una instrucción en lenguaje ensamblador, y puede ser de 12, 14, 16 o
32 bits, dependiendo de la familia

https://cdn.solarbotics.com/products/photos/c6be3a127a5aacafd1c38a09acc34845/lrg/pic.jpg

https://es.wikipedia.org/wiki/Microcontrolador_PIC
 Proteus (electrónica)

Proteus es una compilación de programas de diseño y simulación electrónica, desarrollado por

Labcenter Electronics que consta de los dos programas principales: Ares e Isis, y los módulos VSM
y Electra.

ISIS

El Programa ISIS, Intelligent Schematic Input System (Sistema de Enrutado de Esquemas

Inteligente) permite diseñar el plano eléctrico del circuito que se desea realizar con componentes
muy variados, desde simples resistencias, hasta alguno que otro microprocesador o
microcontrolador, incluyendo fuentes de alimentación, generadores de señales y muchos otros
componentes con prestaciones diferentes. Los diseños realizados en Isis pueden ser simulados en
tiempo real, mediante el módulo VSM, asociado directamente con ISIS.

El módulo VSM

Una de las prestaciones de Proteus, integrada con ISIS, es VSM, el Virtual System Modeling
(Sistema Virtual de Modelado), una extensión integrada con ISIS, con la cual se puede simular, en
tiempo real, con posibilidad de más rapidez; todas las características de varias familias de
microcontroladores, introduciendo nosotros mismos el programa que controlará el
microcontrolador y cada una de sus salidas, y a la vez, simulando las tareas que queramos que
lleve a cabo con el programa. Se pueden simular circuitos con microcontroladores conectados a
distintos dispositivos, como motores, lcd´s, teclados en matriz, etc. Incluye, entre otras, las
familias de PIC's PIC10, PIC12, PIC16, PIC18, PIC24 y dsPIC33. ISIS es el corazón del entorno
integrado PROTEUS. Combina un entorno de diseño de una potencia excepcional con una enorme
capacidad de controlar la apariencia final de los dibujos.wdsDA

https://es.wikipedia.org/wiki/Proteus_(electr%C3%B3nica)

http://img1.imagilive.com/0712/scrn-500d60b2.png
 Advantages of the CCS C Compiler

CCS developed the first C Compiler for Microchip microcontrollers over 20 years ago and continues
to provide software solutions to developers of embedded applications using PIC® MCU and
PIC24/dsPIC® DSC devices. CCS compilers are easy to use and quick to learn. For the less
experienced programmer, a detailed textbook explaining the C language and how it may be
applied to PIC® microcontrollers.

Our compiler products include pro-level optimization, the largest library of built-in functions,
powerful PIC® MCU specific pre-processor commands, and ready-to-run example programs to
quickly jump-start any project. Our massive customer base provides us access to understanding
our customer's requirements while developing advanced features with frequent releases and rare
bugs.

Key Compiler Features:

Easily migrate between all Microchip PIC® MCUs devices

Minimize development time with: peripheral drivers and standard C constructs

C++ style input/output streams with full data formatting to any device or for strings

Use CCS libraries and object code royalty free

Convenient functions like #bit and #byte allow C variables to be placed at absolute addresses

The integral one-bit type (Short Int) permits the compiler to generate very efficient Bit-oriented
code Easily define, set-up and manage interrupts
 QUADX!

Programador/Depurador para PIC, dsPIC y PIC32. Rendimiento y estilo, la herramienta que

necesitas.

QUADX Software

La tarjeta QUADX cuenta con un software de aplicación mediante el cual se gobiernan todas las
funciones de la tarjeta. Es intuitivo y fácil de usar.

Es compatible con las versiones de Windows: Windows ME, Windows XP, Windows Vista,
Windows 7, Windows 8 y Windows 8.1. Compatible con máquinas de 32 y 64 bits.

http://dignal.com/quadx/

http://dignal.com/wp-content/uploads/2015/02/2_opt.png
 Un teclado matricial es un simple arreglo de botones
conectados en filas y colúmnas, de modo que se pueden leer varios botones con el mínimo
número de pines requeridos. Un teclado matricial 4x4 solamente ocupa 4 lineas de un puerto para
las filas y otras 4 lineas para las colúmnas, de este modo se pueden leer 16 teclas utilizando
solamente 8 líneas de un microcontrolador. Si asumimos que todas las columnas y filas
inicialmente están en alto (1 lógico), la pulsación de un botón se puede detectar al poner cada fila
a en bajo (0 lógico) y checar cada columna en busca de un cero, si ninguna columna está en bajo
entonces el 0 de las filas se recorre hacia la siguiente y así secuencialmente.

Un modo simple de detectar la tecla presionada es incrementar una variable con la cuenta de las
teclas revisadas, de este modo al detectaruna pulsación el valor de la cuenta será el valor de la
tecla presionada. Si al final no se presionó ninguna tecla la variable se pone a cero y la cuenta
vuelve a comenzar. El puerto B del microcontrolador 16f628 (así como en el 16f877) viene
preparado especialmente para el control de un teclado matricial 4x4. Para tener siempre un valor
de 1 lógico en las colúmnas del teclado (parte alta del puerto B del pic) es necesario conectar
resistencias de pull-up, sin embargo el puerto B cuenta con resistencias de pull-up integradas, de
ese modo es posible trabajar con un teclado matricial sin necesidad de ningún componente
externo.

http://electronilab.co/wp-content/uploads/2014/06/Teclado-Matricial-de-membrana-4x4-16-
d%C3%ADgitos-Electronilab-04.jpg

http://www.circuitoselectronicos.org/2011/03/teclado-matricial-4x4.html
 ¿Que es un LCD?

El LCD(Liquid Crystal Dysplay) o pantalla de cristal líquido es un dispositivo empleado para la

visualización de contenidos o información de una forma gráfica, mediante caracteres, símbolos o
pequeños dibujos dependiendo del modelo. Está gobernado por un microcontrolador el cual dirige
todo su funcionamiento.

En este caso vamos a emplear un LCD de 16x2, esto quiere decir que dispone de 2 filas de 16
caracteres cada una. Los píxeles de cada símbolo o carácter, varían en función de cada modelo.

http://skpang.co.uk/catalog/images/lcd/lcd162b-ghb.jpg

http://todoelectrodo.blogspot.com/2013/02/lcd-16x2.html
El protoboard o breadbord: Es una especie de tablero con orificios, en la cual se pueden insertar
componentes electrónicos y cables para armar circuitos. Como su nombre lo indica, esta tableta
sirve para experimentar con circuitos electrónicos, con lo que se asegura el buen funcionamiento
del mismo.

Estructura del protoboard: Básicamente un protoboard se divide en tres regiones:

A) Canal central: Es la región localizada en el medio del protoboard, se utiliza para colocar los
circuitos integrados.

B) Buses: Los buses se localizan en ambos extremos del protoboard, se representan por las líneas
rojas (buses positivos o de voltaje) y azules (buses negativos o de tierra) y conducen de acuerdo a
estas, no existe conexión física entre ellas. La fuente de poder generalmente se conecta aquí.

C) Pistas: La pistas se localizan en la parte central del protoboard, se representan y conducen

según las líneas rosas.

http://www.unicrom.com/imagenes/protoboard-1.gif

http://www.circuitoselectronicos.org/2007/10/el-protoboard-tableta-de-experimentacin.html
El calibre de alambre estadounidense (en inglés american wire gauge o AWG) es una referencia de
clasificación de diámetros. En muchos sitios de Internet y también en libros y manuales,
especialmente de origen norteamericano, es común encontrar la medida de conductores
eléctricos (cables) indicados con la referencia AWG. Cuanto más alto es este número, más delgado
es el alambre. El alambre de mayor grosor (AWG más bajo) es menos susceptible a la
interferencia, posee menos resistencia interna y, por lo tanto, soporta mayores corrientes a
distancias más grandes.

https://es.wikipedia.org/wiki/Calibre_de_alambre_estadounidense

http://www.intelix.com/RUB_IMAGES/images/med-res_jpg/22-4C-SO-HT.jpg
Código ccs

#include <16f877.h>

#use delay(clock=4000000)

#fuses xt,noprotect,nowdt

#include <lcd.c> //libreria manejo lcd 4 bits

#byte portB=0x07

#byte portA=0x3f

#BYTE TRISA = 0x85 // Configuramos el TRISA

#BYTE PORTA = 0x05 // Configuramos el PORTA

#use fast_io(D)

#use standard_io (C)

char const KEYS[4][4] = {{'1','2','3','A'} ,//codigo del teclado

{'4','5','6','B'} ,

{'7','8','9','C'} ,

{'*','0','#','D'} }; //se puede cambiar el * por A y el # por B

#byte kbd_port_b = 6

char kbd_getc( )//inicio del codigo del teclado

char tecla=0;

int f,c,t,i,j;

port_b_pullups(true);

set_tris_b(0b00001111); // RB7-RB4 salidas, RB3-RB0 entradas

for(f=0x10, i=0; i<4; f<<=1, i++)

for(c=0x01, j=0; j<4; c<<=1, j++)

{
 kbd_port_b = ~f;

delay_cycles(1);

t = kbd_port_b & 0x0F;

t = ~(t | 0xF0 );

if(t == c)

delay_ms(20);

tecla=KEYS[i ][j ];

while(t==c)

restart_wdt( );

t = kbd_port_b & 0x0F;

t = ~(t | 0xF0) ;

break;

if(tecla)

break;

port_b_pullups(false);

return tecla;

///INICIO DEL PROGRAMA

void main(void)

{
 TRISA = 0xFF;

int c,a,valor,valor1,valor2,valor3;

int piso=0;//servira para la logica del asensor al subir y bajar los pisos

lcd_init(); //inicializa lcd

lcd_putc("SELEC piso (1 .. 4)" ); //presentacion

lcd_gotoxy(1,2); //donde se va a mostrar tecla

delay_ms(500);

while(TRUE)

valor=0;

c=kbd_getc(); //donde recibe el numero del teclado

if(bit_test(PORTA,0) == 1){ // Es RA0 es igual a "1"????

valor=1;

if(bit_test(PORTA,1) == 1){ // Es RA0 es igual a "1"????

valor1=2;

if(bit_test(PORTA,2) == 1){ // Es RA0 es igual a "1"????

valor2=3;

if(bit_test(PORTA,3) == 1){ // Es RA0 es igual a "1"????

valor3=4;

if(c!=0){

if(c=='*'){

lcd_putc('\f');//codigo para recetear el lcd

 }

if(c=='1')// s i recibe el 1 imprime el codigo y trabaja el asensor

output_low(PIN_C7);

delay_ms(5);

output_low(PIN_C6);

delay_ms(5);

output_low(PIN_C4);

delay_ms(5);

output_low(PIN_C5);

delay_ms(5);

if(piso==0 )//condicion si el asensor esta en el primer piso no hace nada

output_low(PIN_C2);

delay_ms(5);

output_low(PIN_C3);

delay_ms(5);

lcd_putc('\f');

lcd_putc("[[P.1]] , 2 , 3 , 4");//lo que se anota en el lcd

output_high(PIN_C4);

delay_ms(1000);

else if(piso==1)//condicion si el asensor esta en el segundo piso y quiero ir al primero deciende el

asensor 1 nivel

output_low(PIN_C2);
 delay_ms(5);

output_high(PIN_C3);

delay_ms(5222);

if(valor==1)

lcd_putc('\f');

lcd_putc("[[P.1]] , 2 , 3 , 4");//lo que se anota en el lcd

output_low(PIN_C3);

delay_ms(50);

output_high(PIN_C4);

delay_ms(50);

else if(piso==2)//condicion si el asensor esta en el tercer piso y quiero ir al primero deciende el

asensor 2 niveles

for(a=0;a<2;a++)

output_low(PIN_C2);

delay_ms(5);

output_low(PIN_C3);

delay_ms(500);

output_high(PIN_C3);

delay_ms(500);

if (a==0){

lcd_putc('\f');
 lcd_putc("1 ,[[P.2]], 3 , 4");//lo que se anota en el lcd

else if(a==1)

if(bit_test(portA,0)==0)

lcd_putc('\f');

lcd_putc("[[P.1]] , 2 , 3 , 4");//lo que se anota en el lcd

output_low(PIN_C3);

delay_ms(50);

output_high(PIN_C4);

delay_ms(50);

else if(piso==3)//condicion si el asensor esta en el cuarto piso y quiero ir al primero deciende el

asensor 3 niveles

for(a=0;a<3;a++)

output_low(PIN_C2);

delay_ms(5);

output_low(PIN_C3);

delay_ms(500);

output_high(PIN_C3);
delay_ms(500);

if (a==0){

lcd_putc('\f');

lcd_putc("1 , 2 ,[[P.3]], 4");//lo que se anota en el lcd

else if(a==1)

lcd_putc('\f');

lcd_putc("1 ,[[P.2]], 3 , 4");//lo que se anota en el lcd

else if(a==2)

lcd_putc('\f');

lcd_putc("[[P.1]] , 2 , 3 , 4");//lo que se anota en el lcd

output_high(PIN_C4);

delay_ms(50);

piso=0;

else if(c=='2')// si recibe el 2 imprime el codigo y trabaja el asensor

output_low(PIN_C7);

delay_ms(5);

output_low(PIN_C6);
delay_ms(5);

output_low(PIN_C4);

delay_ms(5);

output_low(PIN_C5);

delay_ms(5);

if(piso==0)//si esta en el primer piso sube un nivel para ir al segundo

output_high(PIN_C2);

delay_ms(5);

output_low(PIN_C3);

delay_ms(5);

lcd_putc('\f');

lcd_putc("1 ,[[P.2]], 3 , 4");//lo que se anota en el lcd

output_high(PIN_C5);

delay_ms(50);

else if(piso==1)//si esta en el segundo piso no hace nada

output_low(PIN_C2);

delay_ms(5);

output_low(PIN_C3);

delay_ms(5);

lcd_putc('\f');

lcd_putc("1 ,[[P.2]], 3 , 4");//lo que se anota en el lcd

output_high(PIN_C5);

delay_ms(50);
 }

else if(piso==2)//si esta en el tercer piso deciende un nivel para llegar al segundo piso

output_low(PIN_C2);

delay_ms(5);

output_high(PIN_C3);

delay_ms(5);

lcd_putc('\f');

lcd_putc("1 ,[[P.2]], 3 , 4");//lo que se anota en el lcd

output_high(PIN_C5);

delay_ms(50);

else if(piso==3)//si esta en el cuarto piso deciende dos niveles para llegar al segundo piso

for(a=0;a<2;a++)

output_low(PIN_C2);

delay_ms(5);

output_low(PIN_C3);

delay_ms(500);

output_high(PIN_C3);

delay_ms(500);

if (a==0){

lcd_putc('\f');

lcd_putc("1 , 2 ,[[P.3]], 4");//lo que se anota en el lcd

}
else if(a==1)

lcd_putc('\f');

lcd_putc("1 ,[[P.2]], 3 , 4");//lo que se anota en el lcd

output_high(PIN_C5);

delay_ms(50);

piso=1;

else if(c=='3')// si recibe el 3 imprime el codigo y trabaja el asensor

output_low(PIN_C7);

delay_ms(5);

output_low(PIN_C6);

delay_ms(5);

output_low(PIN_C4);

delay_ms(5);

output_low(PIN_C5);

delay_ms(5);

if(piso==0) //si esta en el primer piso sube dos nivel para llegar al tercer piso

for(a=0;a<2;a++)

output_low(PIN_C3);
delay_ms(5);

output_low(PIN_C2);

delay_ms(500);

output_high(PIN_C2);

delay_ms(500);

if (a==1){

lcd_putc('\f');

lcd_putc("1 , 2 ,[[P.3]], 4");//lo que se anota en el lcd

output_high(PIN_C6);

delay_ms(50);

else if(a==0)

lcd_putc('\f');

lcd_putc("1 ,[[P.2]], 3 , 4");//lo que se anota en el lcd

else if(piso==1)//si esta en el segundo piso sube un nivel para llegar al tercer piso

output_high(PIN_C2);

delay_ms(5);

output_low(PIN_C3);

delay_ms(5);

lcd_putc('\f');

lcd_putc("1 , 2 ,[[P.3]], 4");//lo que se anota en el lcd

 output_high(PIN_C6);

delay_ms(50);

else if(piso==2)//si esta en el tercer piso no hace nada

output_low(PIN_C2);

delay_ms(5);

output_low(PIN_C3);

delay_ms(5);

lcd_putc('\f');

lcd_putc("1 , 2 ,[[P.3]], 4");//lo que se anota en el lcd

output_high(PIN_C6);

delay_ms(50);

else if(piso==3)//si esta en el cuarto piso deciende un nivel para llegar al tercer piso

output_low(PIN_C2);

delay_ms(5);

output_high(PIN_C3);

delay_ms(5);

lcd_putc('\f');

lcd_putc("1 , 2 ,[[P.3]], 4");//lo que se anota en el lcd

output_high(PIN_C6);

delay_ms(50);

piso=2;
}

else if(c=='4')// si recibe el 4 imprime el codigo y trabaja el asensor

output_low(PIN_C7);

delay_ms(5);

output_low(PIN_C6);

delay_ms(5);

output_low(PIN_C4);

delay_ms(5);

output_low(PIN_C5);

delay_ms(5);

if(piso==0){

for(a=0;a<3;a++)

output_low(PIN_C3);

delay_ms(5);

output_low(PIN_C2);

delay_ms(500);

output_high(PIN_C2);

delay_ms(500);

if (a==1){

lcd_putc('\f');

lcd_putc("1 , 2 ,[[P.3]], 4");//lo que se anota en el lcd

else if(a==0)

{
 lcd_putc('\f');

lcd_putc("1 ,[[P.2]], 3 , 4");//lo que se anota en el lcd

else if(a==2)

lcd_putc('\f');

lcd_putc("1 , 2 , 3 , [[P.4]]");//lo que se anota en el lcd

output_high(PIN_C7);

delay_ms(50);

else if(piso==1){

for(a=0;a<2;a++)

output_low(PIN_C3);

delay_ms(5);

output_low(PIN_C2);

delay_ms(500);

output_high(PIN_C2);

delay_ms(500);

if(a==0)

{
lcd_putc('\f');

lcd_putc("1 , 2 , [[P.3]] , 4");//lo que se anota en el lcd

else if(a==1)

lcd_putc('\f');

lcd_putc("1 , 2 , 3 , [[P.4]]");//lo que se anota en el lcd

output_high(PIN_C7);

delay_ms(50);

else if(piso==2){

output_high(PIN_C2);

delay_ms(5);

output_low(PIN_C3);

delay_ms(5);

lcd_putc('\f');

lcd_putc("1 , 2 , 3 , [[P.4]]");//lo que se anota en el lcd

output_high(PIN_C7);

delay_ms(50);

else if(piso==3){

output_low(PIN_C2);

delay_ms(5);
 output_low(PIN_C3);

delay_ms(5);

lcd_putc('\f');

lcd_putc("1 , 2 , 3 , [[P.4]]");//lo que se anota en el lcd

output_high(PIN_C7);

delay_ms(50);

piso=3;

else // si no recibe nada solo recetea el lcd

lcd_putc('\f');

lcd_putc("ingrese(1 al 4)");

valor=0;

Diseño en proteus