proyectopedrojoanmiro.webcindario.com/desarrollo_de_proyectos/proyectos... · proyecto...

Proyecto

ROBOT-MINISUMO

Departamento de Electricidad-Electrónica

Ciclo Superior de Desarrollo de Productos Electrónicos

Alumno: Adrián Eduardo Mancero Plúa.

Profesores: Pedro Alonso Sanz

Alfonso García Gallego

Juan Dongil García

Instituto: I.E.S. Joan Miró

Localidad: San Sebastián de los Reyes

Curso: 2007/2008

2 Ciclo Superior de Desarrollo de Productos Electrónicos

I.E.S. Joan Miró (S.S. de los Reyes) / Dpto. Electrónica

Índice: Página

1.- Introducción. .................................................................................................. 4

2.- Diagrama en Bloques del Robot Minisumo. ................................................ 5

2.1.- Esquema electrónico Robot Minisumo. ………………….…………... 6

3.- Análisis de los Bloques. .................................................................................. 7

3.1.- Alimentación del Circuito. .................................................................... 7

3.2.- Cargador del Programa……... ............................................................... 8

3.3.- Etapa de Potencia. ................................................................................. 9

3.4.- Sensores de distancia GP2D12............. .................................................. 11

3.5.- Sensores infrarrojos CNY70. .................................................................. 12

3.6.- Acondicionador de señal. ........................................................................ 13

3.7.- Control. Microcontrolador PIC PIC16F876A. ........................................ 13

3.8.- Receptor de Radiofrecuencia. ................................................................. 14

3.11.- Mando. .................................................................................................. 15

4.-Esquema eléctrico de simulación con Proteus. ............................................... 16

4.1.- Simulación del Robot Minisumo. ............................................................ 16

5.- Diseño de Placas de Circuitos Impresos. .......................................................... 17

5.1.- Fuente de Alimentación y Cargador del Programa MAX232 .................... 17

5.1.1.- Esquema Eléctrico. ................................................................. 17

5.1.2.- Cara de Componentes y de pistas Top Copper. ..................... 18

5.1.3.- Cara de pistas Bottom Copper. .............................................. 18

5.2.- Control de Potencia. ................................................................................... 19

5.2.1.- Esquema Eléctrico. ................................................................ 19

5.2.2.- Cara de Componentes y de pistas Top Copper. .................... 20

5.2.3.- Cara de pistas Bottom Copper. ............................................. 20

5.3.- Control. ...................................................................................................... 21

5.3.1.- Esquema Eléctrico. ................................................................ 21

5.3.2.- Cara de Componentes y de pistas Top Copper. .................... 22

5.2.3.- Cara de pistas Bottom Copper. ............................................. 22



Índice: Página

5.3.- Mando. ..................................................................................................... 23

5.4.1.- Esquema Eléctrico. ................................................................... 23

5.4.2.- Cara de Componentes y de pistas Top Copper. ........................ 23

5.4.3.- Cara de pistas Bottom Copper. ................................................. 23

6.- Lista de Componentes. ........................................................................................... 24

6.1.- Listado General.............................................................................. 24

6.3.- Mando. .......................................................................................... 25

7.- Coste Económico. ................................................................................................... 27

7.1.- Desarrollo del Proyecto. ................................................................ 27

7.2.- Material. ....................................................................................... 27

8.- Referencias. ........................................................................................................... 27

9.- Programas Robot Minisumo (Programas de Prueba)……………………………………………

9.1.- CONTROL DE MOTORES (simulación)………………………………………………..

9.2.- SIMULACIÓN SENSORES……………………………………………………………...

9.3.- SIMULACIÓN SERVO UÑA……………………………………………………………

9.4.- PRUEBA GP2D12………………………………………………………………………..

9.5.- SIMULACIÓN SENSORES CNY70 (PATILLAS RB5 Y RB6)………………………...

9.6.- SIMULACIÓN SENSORES CNY70 (PATILLAS RB4 Y RB7)………………………...

9.7.- CONTROL DE MOTORES CON GP2D12 Y CNY70…………………………………..

10.- Librerías…………………………………………………………………………………………….

10.1.- Servo Futaba 10bit……………………………………………………………………….

10.2.- LCD1………………………………………………………………………………….....

10.3.- KBD1…………………………………………………………………………………….

10.4.- 16F876…………………………………………………………………………………..



1.- Introducción

Este proyecto consiste en realizar un robot que sea capaz de localizar, seguir, empujar y tirar

a otro robot de similares condiciones, de un tatami.

Este Robot tiene la misión, como su nombre lo indica, de luchar con otros robots similares

en peso y tamaño, para ello se han utilizado dos motores, controlados mediante cuatro

sensores ópticos CNY70, y el inversor de giro L293 para que de esta manera pueda realizar

giros de derecha a izquierda y de izquierda a derecha. Para el control del robot se han

empleado técnicas digitales que tiene como núcleo principal el PIC 16F876A.

Para poder localizar al contrincante hemos empleado los Sensores Infrarrojos GP2D12 que

miden la distancia a la que se encuentra su oponente, así podremos atacar y tirar al otro

robot del tatami.

Además, el robot fue diseñado para poder ser controlado como coche teledirigido.

En todo momento el control del robot puede hacerse manualmente.

Existe una comunicación entre el robot y un mando en radio frecuencia con los módulos de

CEBECK C-0503 y C-0504. Que son un transmisor y receptor de datos en modulación AM

que trabajan a una frecuencia portadora 433,92 MHz y tienen un Ancho de Banda de 4 KHz.

El diseño del proyecto lo hacemos mediante una herramienta llamada Proteus, que permite

simular el hardware y el software a la vez, pudiendo ejecutarse paso a paso cada programa.

Se puede trabajar con ficheros .ASM y C.

Para la programación del PIC 16F876A hemos utilizado una herramienta llamada PIC C

Compiler.

El software se puede ser grabado en el robot directamente sin necesidad de extraer el

microcontrolador, para ello se ha utilizado el grabador PICdownloader.exe.

Los microcontroladores tienen que tener cargado previamente un programa de

comunicaciones para comunicarnos con un Ordenador Personal.



2.- Diagrama en Bloques del Robot Minisumo



2.1.- Esquema electrónico Robot Minisumo.



3.- Análisis de los Bloques.

3.1.- Alimentación del Circuito.

La Fuente de Alimentación es un circuito que se encargar de obtener una tensión de 5V continua a

partir de una superior de 9V, Para esto se ha utilizado el regulador de tensión LM350K (U1) que

nos puede dar una corriente de salida máxima (Imax) de 3A. De esta Fuente de Alimentación

también obtenemos 8.4V para el funcionamiento de los motores

Los condensadores C1 y C2 funcionan como filtros de ruido, se colocan a la entrada del

circuito y lo más cerca del regulador LM350K.

El condensador C15 lo colocamos para estabilizar la señal de referencia funcionando como

filtro del potenciómetro (RV1).

Los condensadores C3 y C4 funcionan como filtros de ruido pero esta vez se colocan a la

salida del regulador LM350K.

El diodo D1 tiene la misión de proteger el circuito en caso de cambiar la polaridad de la

batería.

El diodo D2 funciona como protector del integrado LM350K, en indirecta el diodo el

circuito funciona y en directa el diodo se funciona como un cable.

El diodo D4 se coloca para copiar la polaridad del circuito.

En conclusión los diodos D2 y D4 los colocamos para la protección del Integrado LM350K

en caso de sobretensiones e inversiones de tensión a la salida.

El diodo Led D3 nos indica que la fuente está encendida, estando limitada su corriente a 20

mA por la resistencia R1.

Y para terminar, de esta Fuente de Alimentación obtenemos una tensión de 8.4V para la

alimentación de los motores ya que 5v no es una tensión suficiente para el funcionamiento de los

motores.



3.2.- Cargador del Programa.

El circuito integrado MAX232 lleva internamente 2 conversores de nivel de TTL a RS232 y otros 2

de RS232 a TTL con lo que en total podremos manejar 4 señales, por lo general las más usadas son;

TX, RX, RTS, CTS, estas dos últimas son las usadas para el protocolo handshaking (Protocolo de

comienzo de comunicación entre dos máquinas o sistemas) pero no es imprescindible su uso. Para

que el MAX232 funcione correctamente deberemos de poner unos condensadores externos de 1µF.

El funcionamiento del MAX232 consiste en intercambiar niveles TTL a RS232, donde un “0” en

TTL equivale a 0V y en RS232 equivale a una tensión comprendida entre 3 y 15V. Un “1” en TTL

equivale a 5V en RS232 equivalente a una tensión comprendida entre -3 y -15V.

El Circuito Integrado MAX 232 se encarga de convertir los niveles de TTL a RS232.

Pin Señal In /

Out Descripción

1 DCD In Detector de Portadora de Datos

2 RxD (RD)

In Recepción de Datos

3 TxD (TD)

Out Transmisión de Datos

4 DTR Out Terminal de Datos Listo

5 GND - Masa 6 DSR In Dispositivo de Datos

Listo

7 RTS Out Petición de envío

8 CTS In Dispuesto para enviar

9 RI In Indicador de llamada



3.3.- Etapa de Potencia. (Control de potencia mediante integrado L293B.)

La intensidad de salida de las patillas del PIC no es suficiente para poner en marcha los motores, así

que es necesario recurrir al integrado L293B, controlador de motores, formado por un doble puente

“H”, y que es capaz de dar 1 A por canal.



El regulador L293B tiene dos terminales de alimentación, una de ellas es necesaria para alimentar el

propio circuito integrado, el cuál debe ser de 5V(Vcc), y otra para la tensión en los motores que en este

caso utilizaremos los 9V(Vs) que nos lo proporciona la Fuente de Alimentación. Este circuito integrado

permite tener el control de la velocidad de rotación del motor, se habilitan de dos en dos por medio de

las señales de control EN1 (OUT 1 y 2) y EN2 (OUT 3 y 4), en la siguiente tabla vemos el

funcionamiento de las entradas y como responden las salidas.

ENn INn OUTn 1 1 1 1 0 0 0 1 Z 0 0 Z

HZ = Alta Impedancia

Así podemos ver que poniendo a nivel alto la entrada de habilitación "EN", la salida de este "OUT"

pasa de alta impedancia al mismo nivel que se encuentre la entrada "IN" pero amplificado en

tensión y en corriente, siendo esta de 1A máximo.

En este diseño colocamos optoacopladores en la salida de cada una de las entradas del L293B

porque al inicio del arranque del motor, este demanda más voltaje y corriente que la nominal, por lo

que requiere que aislemos las salidas del puerto del microcontrolador, ya que una demanda excesiva

de estos parámetros, pueden llegar a dañar su estructura y funcionalidad.



3.4.- Sensores de Distancia GP2D12.

Sensor que mide distancia mediante triangulación con PSD (Detector Sensible a la Posición), Led

infrarrojo y circuito de procesado de señal, valor nominal entre 0 y 3V dependiendo de la distancia.

La información de la distancia se extrae midiendo el ángulo recibido. Si el ángulo es grande, el

objeto esta cerca, porque el triangulo es ancho. Si el ángulo es pequeño, el objeto está lejos, por lo

que el triángulo formado es estrecho.

El LED infrarrojo emite el haz de luz a través de una pequeña lente convergente que hace que el haz

emisor llegue de forma paralela al objeto. Cuando la luz choca con un obstáculo, una cierta cantidad

de luz se refleja, casi todas las sustancias tienen un grado bastante grande de rugosidad de la

superficie que produce una dispersión hemisférica de la luz (la llamada reflexión no teórica).

Alguno de estos haces de esta luz rebota hacia el sensor que es recibido por la lente. La lente

receptora también es una lente convexa. Actúa para convertir el ángulo de posición. Si un objeto se

pone en el plano focal de una lente convexa y los otros rayos de luz paralelos en otro lado, el rayo

que pasa por el centro de la lente atraviesa inalterado o marca el lugar focal. Los rayos restantes

también enfocan a este punto.

Concepto de triangulación GP2D12

Características:

1. Menos influencia del color de los objetos reflexivos

2. Línea indicadora de distancia output/distance :

Tipo de salida indicadora de la distancia analógica (tensión analógica) para el GP2D12.

Distancia del detector de 10 a 80 cm.



3.5.- Sensores infrarrojos CNY70.

Los sensores que utilizamos son CNY70.

Son sensores infrarrojos formados por un fotodiodo y un transistor. Estos sensores son ópticos y

funcionan mediante reflexión, el fotodiodo emite luz infrarroja cuando se refleja en el borde blando,

formándose así la reflexión con una distancia de 2.8 mm entre ellos.

.

Funcionamiento del sensor:

El principio en el que se basa el funcionamiento del sensor CNY70 es en la emisión de un haz de

luz infrarroja por medio del diodo emisor. Dicho haz de luz se refleja sobre una superficie llegando

así a la base del fototransistor. De esta manera a medida que la superficie reflejante sea más clara,

mayor corriente se producirá a través del fototransistor y así se obtendrá mayor voltaje a la salida y

mientras más oscura sea la superficie, menor será la intensidad de rayo infrarrojo reflejado por lo

que el voltaje de salida en el fototransistor será menor.

Cuando el sensor este sobre blanco tenemos un “1” porque refleja. El transistor se satura y a la

salida del 74HC14 tenemos “0”.

Cuando el sensor este sobre negro tenemos un “0” porque no refleja. El transistor no se satura y a la

salida del 74HC14 tenemos “1”.

Esquema sensor infrarrojo CNY70



3.6.- Acondicionador de señal

El acondicionador de señal está compuesto por un conector (a su vez conectado con los sensores),

dos resistencias y una Trigger Smith.

El encapsulado que usamos es un 74HC14. El cual posee seis Trigger Schmitt.

Un Trigger Schmitt cambia su estado de salida cuando la tensión en su entrada sobrepasa un

determinado nivel. La salida vuelve a cambiar a otro voltaje distinto, suele ser a un voltaje menor

que el primero. A este ciclo se le conoce como histéresis.

3.7.- Control. Microcontrolador PIC PIC16F876A.

En la arquitectura del Hardware del robot el componente principal es el MICROCONTROLADOR

PIC16F876A.

Se ha utilizado este microcontrolador, ya que el robot está diseñado para controlar varios periféricos

(motores, servomotores, sensores infrarrojos y sensores ópticos, radio frecuencia, cargador del

programa controlador, etc) y es necesario muchas líneas de entrada y salida. Este microcontrolador

dispone de los elementos necesarios para controlar los sensores y motores como los Timers,

convertidores de analógica a digital, salidas de control por PWM.

El microcontrolador PIC 16F876A trabaja a una frecuencia de 1 MHz y ejecuta una instrucción en

1µs.

Tiene un Jumper JUMPER que nos sirve para cargar el programa procedente del Ordenador

Personal en el microcontrolador o recibir los datos del receptor de RF.



Un pulsador de Inicio nos servirá para activar el robot Minisumo. Cuando el robot esté situado en la

posición indicada el robot empezará a funcionar según el programa introducido en el

microcontrolador.

3.8.- Receptor de Radiofrecuencia.

La Tarjeta Receptora de Datos CEBEK C-0504 es un circuito híbrido encargado de recibir, vía

radiofrecuencia, los datos digitales procedentes del Mando. La señal digital tiene que tener una

frecuencia entre 20 Hz < fo < 4 KHz. y una portadora de 433,92 MHz. Este circuito demodula la

señal de AM obteniendo los datos transmitidos.



3.9.- Mando.

El mando tiene la misión de transmitir un código asociado a cada pulsador, para poder controlar el

robot.

El microcontrolador PIC 16F876a lee los pulsadores y transmite los códigos vía serie a la tarjeta

transmisora de radiofrecuencia a una velocidad de 1562,5 baudios por segundo. Es una transmisión

asíncrona (1bit de comienzo, 8bit de Datos, 1 bit de parada sin bit de paridad).

La Alimentación procede de un regulador 7805 que suministra 5V a todos los circuitos.

El TRT “Q1E” tiene la misión de deshabilitar la tarjeta de radiofrecuencia cuando esta no transmite

datos.

La Tarjeta Emisora SAW para Datos 433,92 MHz. CEBEK C-0503 es un circuito híbrido

encargado de transmitir vía radiofrecuencia, los datos digitales procedentes del microprocesador

(TX). La señal digital tiene que tener una 20 Hz < fo < 4 KHz. Se modula en AM cuya frecuencia

portadora es de 433,92 MHz.

El microcontrolador PIC 16F876aA trabaja a una frecuencia de 4 MHz y ejecuta una instrucción en

1µs.

El Led D7E nos indica que el mando está encendido, está limitada su corriente en 20 mA.

El resto de los LED se iluminan cuando activamos el Pulsador correspondiente.

El diodo D7E tiene la misión de proteger el circuito en cado de invertir la Batería.

Los condensadores C1 y C2 son filtros.

VS

S

RB0E

RB1E

RB2E

RB3E

RB4E

RB1E RB3E RB0E RB2E RB4E

Q1EBD136_JOAN

Emisor de Datos CEBEK C-0503

GN

D1

1

Ve

2

-3

GN

D2

4

An

tena

11

GN

D3

13

Vcc

15

E_RF1E

1

CON1E

BORNIER1_JOAN

VI1

VO3

GN

D2

U2E7805_JOAN

A K

D6E

1N4007_JOAN12

BAT1E9V

RA0/AN02

RA1/AN13

RA2/AN2/VREF-4

RA4/T0CKI6

RA5/AN4/SS7

OSC1/CLKIN9

OSC2/CLKOUT10

RC1/T1OSI/CCP212

RC2/CCP113

RC3/SCK/SCL14

RB7/PGD28

RB6/PGC27

RB526

RB425

RB3/PGM24

RB223

RB122

RB0/INT21

RC7/RX/DT18

RC6/TX/CK17

RC5/SDO16

RC4/SDI/SDA15

RA3/AN3/VREF+5

RC0/T1OSO/T1CKI11

MCLR/Vpp/THV1

U1E

PIC16F876_JOAN

R7E2.2k

X1E

4MHz

C3E

15pF

C4E

15pF

R1E220

R2E220

R3E220

12

SW1E

12

SW3E

12

SW2E

AK

D1ELED-YELLOW_JOAN

AK

D2ELED-GREEN_JOAN

AK

D3ELED-RED_JOAN

R6E220

AK

D7ELED-RED_JOAN

Mando

1 2

SW6E

INTERRUPTOR_JOAN

C2E220uF

VDD

R4E220

12

SW4E

AK

D4ELED-RED_JOAN

R5E220

12

SW5E

AK

D5ELED-RED_JOAN

C1E220uF

VDD

Izquierda Atras Adelante Parar Derecha



4.-Esquema eléctrico de simulación con Proteus.

4.1.- Simulación del Robot Minisumo.



5.- Diseño de Placas de Circuitos Impresos.

5.1.- Fuente de Alimentación y Cargador del Programa con MAX232.

5.1.1.- Esquema Eléctrico.



5.1.2.- Cara de Componentes y de pistas Top Copper.

5.1.3.- Cara de pistas Bottom Copper.



5.2.- Control de Potencia.




5.3.- Control.




5.4.- Mando.


5.4.2.- Cara de Componentes 5.4.3.- Cara de pistas Bottom Copper.

y de pistas Top Copper .

VS

S

RB0E

RB1E

RB2E

RB3E

RB4E

RB1E RB3E RB0E RB2E RB4E

Q1EBD136_JOAN

Emisor de Datos CEBEK C-0503

GN

D1

1

Ve

2

-3

GN

D2

4

An

tena

11

GN

D3

13

Vcc

15

E_RF1E

1

CON1E

BORNIER1_JOAN

VI1

VO3

GN

D2

U2E7805_JOAN

A K

D6E

1N4007_JOAN12

BAT1E9V

RA0/AN02

RA1/AN13

RA2/AN2/VREF-4

RA4/T0CKI6

RA5/AN4/SS7

OSC1/CLKIN9

OSC2/CLKOUT10

RC1/T1OSI/CCP212

RC2/CCP113

RC3/SCK/SCL14

RB7/PGD28

RB6/PGC27

RB526

RB425

RB3/PGM24

RB223

RB122

RB0/INT21

RC7/RX/DT18

RC6/TX/CK17

RC5/SDO16

RC4/SDI/SDA15

RA3/AN3/VREF+5

RC0/T1OSO/T1CKI11

MCLR/Vpp/THV1

U1E

PIC16F876_JOAN

R7E2.2k

X1E

4MHz

C3E

15pF

C4E

15pF

R1E220

R2E220

R3E220

12

SW1E

12

SW3E

12

SW2E

AK

D1ELED-YELLOW_JOAN

AK

D2ELED-GREEN_JOAN

AK

D3ELED-RED_JOAN

R6E220

AK

D7ELED-RED_JOAN

Mando

1 2

SW6E

INTERRUPTOR_JOAN

C2E220uF

VDD

R4E220

12

SW4E

AK

D4ELED-RED_JOAN

R5E220

12

SW5E

AK

D5ELED-RED_JOAN

C1E220uF

VDD

Izquierda Atras Adelante Parar Derecha



6.- Lista de Componentes.

6.1.- Listado General

Lista de materiales Listado General.

Título: Listado General

Autor: Adrián Mancero P.

Revisión:

Creado: domingo, 09 de noviembre de 2008

Ultima modificación: sábado, 14 de marzo de 2009

Número de Componentes: 158

28 Resistencias

Cantidad: Referencia Valor Coste Unitario Coste

2 R22, R23 4.7k 0.05 0.10

6 R2, R4, R6, R8, R18, R21 10k 0.05 0.30

2 R24, R25 100 0.05 0.10

4 R6, R7, R9, R10 330 0.05 0.20

9

1

4

R1, R3, R5, R7, R9, R10, R12, R14, R16

R38 R11, R13, R15, R17

220

240

18k

0.05

0.05

0.05

0.45

0.05

0.20

12 Condensadores


1 C1 2200µF 0.05 0.05

5 C2, C4, C9, C10, C11 100nF 0.05 0.25

3 C3, C5, C8 1µF 0.05 0.15

2 C13-C16 15pF 0.05 0.10

1 C15 10µF 0.05 0.05

10 Circuitos Integrados.


1 U1 LM350K_JOAN 3 3

2 U2 MAX232 2 2

4 U3, U4, U5, U6 OPTOCOUPLER-NPN 0.5 0.50

1 U7 74HC14 0.5 0.50

1 U9 L293 2 2

1 U10 PIC16F876_JOAN 5 5

13 Diodos.


11 D1, D2, D4, D5, D6, D7, D8, D9, D10,

D11, D12

LED-RED_JOAN 0.20 2.20

2 D3 LED-GREEN_JOAN 0.20 0.20



85 Componentes diversos.


2 INFR1, INFR2 GP2D12 16 32

2 ON-OFF INTERRUPTOR_JOAN 0.2 0.20

4 OP1, OP2, OP3, OP4 CNY70 0.5 2

8 MASAS BORNIER 1 0.15 1.20

2 BATERIA 9V 10 10

2 INICIO, SENSOR CONTACTO PULSADOR_JOAN 0.20 0.40

4 J1, J1A, J3, J3A CONN-H10 0.15 0.60

2 J2A, J3A (Macho-Hembra Cuadrado) CONN-SIL5 0.15 0.30

10 J5, J5A, J6, J6A, J7, J7A, J8, J8A, JUMPER, PRG_A-B

CONN_SIL3_JOAN 0.10 1

2 Conector de MOT_ DER, MOT_IZQ Bornier 2 0.30 0.60

2 MOTOR DERECHO, MOTOR IZQUIERDO

9V 10 20

2 SER1, SER2 SERVOMOTOR-PWM_JOAN 5 10

8 Arandela Plástico Métrica 3 0.05 0.4

1 RF1 ANTENA_JOAN 0.0 0.0

1 Conector de RF2 CONN-SIL15 0.5 0.50

1 RF2 CEBEK-C-0504_JOAN 7 7

1 RV1 5k 0.30 0.30

1 CRISTAL CRYSTAL_JOAN (1 MHz) 1 1

3 Placa de C.I. 70 x 75 cm. 5.5 16.5

1 Zócalo de C.I. 28 patillas 0.5 0.50

2 Zócalo de C.I. 6 patillas 0.5 1

14 Separadores metálicos Macho-Hembra Métrica 3 0.5 7

8 Tuercas Métrica 3 0.1 0.80

6 Tornillos Métrica 3 0.1 0.60

4 Tornillos Métrica 3 0.1 0.40

2 Rueda Madera Diámetro 6.4cm 0.5 1

Coste total Listado General 132,70 €

6.2.- Mando.

Lista de materiales Mando.DSN

Título: Mando.DSN

Autor: Pedro Alonso Sanz, Alfonso García Gallego, Juan Dongil García

Revisión:

Creado: miércoles, 16 de febrero de 2005

Ultima modificación: viernes, 08 de febrero de 2008

Número de Componentes: 49

7 Resistencias.


6 R1E-R6E 220 0.05 0.30



1 R7E 2.2k 0.05 0.05

4 Condensadores.


2 C1E, C2E 220uF 0.30 0.60

2 C3E, C4E 15pF 0.05 0.10

2 Circuitos Integrados.


1 U1E PIC16F876_JOAN 5 5

1 U2E 7805_JOAN 1 1

1 Transistor.


1 Q1E BD136_JOAN 1 1

7 Diodos.


1 D1E LED-YELLOW_JOAN 0.20 0.20

1 D2E LED-GREEN_JOAN 0.20 0.20

4 D3E-D5E, D7E LED-RED_JOAN 0.20 0.80

1 D6E 1N4007_JOAN 0.20 0.20

28 Componentes diversos.


1 Conector de BAT1E Bornier 2 0.30 0.30

1 CON1E BORNIER1_JOAN 0.00 0.00

1 Conector de E_RF1E CONN-SIL15 0.15 0.15

1 E_RF1E CEBEK-C-0503_JOAN 7 7

5 SW1E-SW5E PULSADOR_JOAN 0.20 1

1 SW6E INTERRUPTOR_JOAN 1 1

1 X1E CRYSTAL_JOAN

(4 MHz)

1 1

1 Placa de C.I. 50 x 110 cm. 6 6

1 Zócalo de C.I. 28 patillas 0.5 0.5

1 Batería de petaca 9V 1 1

4 Separadores metálicos Macho-Hembra Métrica 3 0.5 2

4 Tuercas Métrica 3 0.1 0.4

4 Tornillos Métrica 3 x 10 mm. 0.1 0.4

1 Porta Baterías 0.5 0.5

1 Soporte de plástico 50 x 110 cm. 1 1

Coste total 2 Mando 31,75 €



7.- Coste Económico.

7.1.- Desarrollo del Proyecto.

Coste 20 € / Hora.

10 Horas de desarrollo Hardware. .................................................................. 200 €

30 Horas de desarrollo Software. ................................................................... 600 €

10 Horas de montaje del Prototipo. ................................................................ 200 €

10 Horas de realización de la Memoria. ........................................................ 200 €

5 Horas de búsqueda de materiales. .............................................................. 100 €

10 Horas de Pruebas. ...................................................................................... 200 €

______

1500 €

7.2.- Material.

Listado General. ............................................................................................ 132,70 €

Mando. .................................................................................. ........................ 31,75 €

_______

164,45 €

Total. ..................................................................................................................... 1664,45 €

8.- Referencias.

[1] Libro: Título: Microcontroladores PIC16F84. Desarrollo de proyectos (2ª Edición)

Autores: Enrique Palacios, Fernando Remiro, Lucas J. López.

Editorial: Ra_Ma

[2] Libro: Título: Compilador C CCS y Simulador Proteus para Microcontroladores PICC

Autor: Eduardo García Breijo

Editorial: marcombo

[3] Libro: Título: Tecnología de Circuitos Impresos

Autores: Claudio Fernández González, José Luis Lázaro Galilea, Ignacio Fernández Lorenzo,

Jesús Ureña Ureña, Felipe Espinoza Zapata.

[4] Empresa suministradora de materiales:

Diotronic S.A. C/Juan Bravo 58. Pagina Web: www.ditronic.com

Ingeniería de Sistemas Programados. Pagina Web: www.microcontroladores.com

[3] Motores COPAL Pagina Web: www.voti.nl/winkel/catalog.html Páginas WEB visitadas:

www.microchip.com

www.datasheetcatalog.com

http://www.ditronic.com/

http://www.microcontroladores.com/

http://www.voti.nl/winkel/catalog.html

http://www.datasheetcatalog.com/



9.- Programas Robot Minisumo (Programas de Prueba).

9.1.- CONTROL DE MOTORES (simulación).

//**************CONTROL DE MOTORES CON RETARDO DE 500MS ************************

#include <16F876A.h>

#FUSES XT,NOWDT

#use delay(clock=4000000)

#BYTE TRISA = 0x85 // TRISA en 85h.

#BYTE portA = 0x05 // PORTA en 05h.

#BYTE TRISB = 0x86 // TRISB en 86h.

#BYTE portB = 0x06 // PORTB en 06h.

#BYTE TRISC = 0x87 // TRISC en 87h.

#BYTE portC = 0x07 // PORTC en 07h.

#BIT RB3 = 0x06.3 // RB1 en 0x06 patilla 3.


#BIT RA4 = 0x05.4 // RA4 en 0X05 patilla 4.

#BIT RC0 = 0x07.0 // RC0 en 0x07 patilla 0.

// ************************** Función principal o programa principal ************************

void main()

{

TRISA = 0B11101111;

TRISB = 0B11100011;

TRISC = 0B11111110;

while (true)

{

RB2 = 0; // Motor parado.

RB3 = 0;

RA4 = 0;

RC0 = 0;

delay_ms(500); // Retardo 500 ms.

RB2 = 1; // Motor gira hacia delante.

RB3 = 0;

RA4 = 1;

RC0 = 0;

delay_ms(500); // Retardo 500 ms.

}

}

9.2.- SIMULACIÓN SENSORES.

//*************************SIMULACIÓN SENSORES INFRARROJOS *****************************


#FUSES XT,NOWDT


















// ************************* Función principal o programa principal *****************************

void main()

{

TRISA = 0B11101111;

TRISB = 0B11110011;

TRISC = 0B11111110;

RB3 = 0;

RB2 = 0;

RA4 = 0;

RC0 = 0;

RB4 = 0;

RB5 = 0;

RB6 = 0;

RB7 = 0;

while(1)

{

if(RB4==1){ // Giro Derecha.

RB2 = 0;

RB3 = 1;

RA4 = 1;

RC0 = 0;

}

if(RB5==1){ // Giro Izquierda.

RB2 = 1;

RB3 = 0;

RA4 = 0;

RC0 = 1;

}

if(RB6==1){ // Giro adelante.

RB2 = 0;

RB3 = 1;

RA4 = 0;

RC0 = 1;

}



if(RB7==1){ // Giro atrás.

RB2 = 1;

RB3 = 0;

RA4 = 1;

RC0 = 0;

}

}

}

9.3.- SIMULACIÓN SERVO UÑA. //**************************SIMULACIÓN SERVO UÑA ******************************


#device adc=10 // Conversor Analógico Digital de 10 bit el

// PIC 16F876A puede trabajar con 8 o 10 bit de resolución.

#FUSES XT,NOWDT


#include <Servo_Futaba_10bit.c> // Incluimos el driver que contiene las

//funciones de control de los Servos de Futaba.

// ************************ Función principal o programa principal ***********************

void main()

{

int16 TH;

Inicializacion_Futaba_RC2(); // Inicialización del Servo en RC2

while (true) // Bucle infinito.

{

TH = 25;

Futaba_RC2(TH); // Posicionar el Servo de la patilla RC2.

delay_ms(1000);

TH = 41;


delay_ms(1000);

TH = 57;


delay_ms(1000);

TH = 73;


delay_ms(1000);

TH = 100;


delay_ms(2000);

TH = 41;


delay_ms(1000);

TH = 25;


delay_ms(1000);

}

}



9.4.- PRUEBA GP2D12.

//***************PRUEBA GP2D12: VISUALIZACIÓN DE DISTANCIA EN LCD ******************

#include <16F877.h>

#device adc=10 // Conversor Analogico Digital de 10 bit el

//PIC 16F876A puede trabajar con 8 o 10 bit de resolucion.

#FUSES XT,NOWDT


#include <LCD.c> // Incluimos el driver LCD.c que contiene

//las funciones de control del LCD.

#include <driver_gp2d12.c>

//*******************************PROGRAMA PRINCIPAL****************************************

void main()

{

int16 q;

float d,

v;

setup_adc_ports(0); // Seleccionamos el Puerto A como entradas Analogicas. Mirar ADCON1.

setup_adc(ADC_CLOCK_INTERNAL); // Fuente de reloj RC interno.

lcd_init(); // Inicializamos el LCD.

for (;;) // Bucle infinito.

{

set_adc_channel(0); // Habilitación canal 0 "AN0"

delay_us(20); // Retardo de 20uS necesaria para respetar el tiempo de Adquisicion Tad.

q = read_adc(); // Lectura canal 0 "AN0"

v = (5.0 * q) / 1024.0; // Conversion a tension del codigo digital "q".

d=Gp2d12_v_d(v);

lcd_gotoxy(1,1); // Posicionamos el Cursor en la posicion 1, linea 1.

printf(lcd_putc, "voltios = %01.3fV", v); // Saltamos de linea y escribimos en el

//LCD "VOLTAJE =" y 4 digitos de "P"

// en formato truncado de 4 digitos con 3 decimales y el caracter "V".

lcd_gotoxy(1,2);

printf(lcd_putc, "d = %01.3fcm",d ); // Saltamos de linea y escribimos en el

//LCD "VOLTAJE =" y 4 digitos de "P"

// en formato truncado de 4 digitos con 3 decimales y el caracter "V".

}

}

9.5.- SIMULACIÓN SENSORES CNY70 (PATILLAS RB5 Y RB6). //******************SIMULACIÓN SENSORES CNY70 (PATILLAS RB5 Y RB6)***********************






#FUSES XT,NOWDT
















// ********************************* Función principal o programa principal **************************

void main()

{

TRISA = 0B11101111;

TRISB = 0B11110011;

TRISC = 0B11111110;

while (1)

{

if(RB5==1|RB6==1){ //Si RB5 = 1 o RB6 = 1 motores atrás

RB2 = 1;

RB3 = 0;

RA4 = 1;

RC0 = 0;

}

else{ // Sino motores adelante

RB2 = 0;

RB3 = 1;

RA4 = 0;

RC0 = 1;

}

}

}

9.6.- SIMULACIÓN SENSORES CNY70 (PATILLAS RB4 Y RB7). //******************SIMULACIÓN SENSORES CNY70 (PATILLAS RB4 Y RB7)***********************




#FUSES XT,NOWDT


















// *************************** Función principal o programa principal **************************

void main()

{

TRISA = 0B11101111;

TRISB = 0B11110011;

TRISC = 0B11111110;

while (1)

{

if(RB4==1||RB7==1){ //Si RB4 = 1 o RB7 = 1 motores atrás

RB2 = 1;

RB3 = 0;

RA4 = 1;

RC0 = 0;

}

else{ // Sino motores adelante

RB2 = 0;

RB3 = 1;

RA4 = 0;

RC0 = 1;

}

}

}

}

9.7.- CONTROL DE MOTORES CON GP2D12 Y CNY70.

//*********************CONTROL DE MOTORES CON GP2D12 Y CNY70 ************************




#FUSES XT,NOWDT


#include <driver_gp2d12.c>









#BIT TA4 = 0x85.4 // TRISA en 85h.





#BIT RB4 = 0x06.4

#BIT RB5 = 0x06.5

#BIT RB6 = 0x06.6

#BIT RB7 = 0x06.7

#BIT RBIF = 0x0B.0 // RBIF en 0x0B patilla 0. Necesario para Proteus

// ************************ Declaración de funciones *******************************

void cny70(void);

void gp2d12(void);

// ******************* Función principal o programa principal **********************

void main()

{

int n; // Necesario para borrar el flag en el Proteus

TRISA = 0B11101111;

TRISB = 0B11110011;

TRISC = 0B11111110;

port_b_pullups(TRUE); // Habilitamos resistencias pullup.

n = portB; // Necesario para borrar el flag en el Proteus

RBIF = 0; // Necesario para borrar el flag en el Proteus

enable_interrupts(int_rb); // Habilitamos la interrupción por cambio de nivel de RB4, RB5, RB6, RB7.

enable_interrupts(int_ext); // Habilitamos la interrupción INT de la patilla RB0.

ext_int_edge(L_TO_H); // Que la interrupción de INT sea por flanco de subida.

enable_interrupts(GLOBAL); // Habilitamos la Interrupción General.

while (TRUE) // Bucle infinito de espera

{

gp2d12();

}

}

// ****** Atención a la interrupción por cambio en RB4,RB5,RB6 y RB7. ***************

#INT_RB

void cny70 (void)

{

int i;

while(RB5==1|RB6==1){ // Interrupción por patillas RB5 y RB6.

// Motor gira en sentido contrario.

RB2 = 1;

RB3 = 0;

RA4 = 1;



RC0 = 0;

}

while(RB4==1|RB7==1){ // Interrupción por patillas RB4 y RB7.

// Motor gira en sentido contrario.

RB2 = 1;

RB3 = 0;

RA4 = 1;

RC0 = 0;

}

i = portB; // Necesario en el Proteus, para poder borrar el fl

}

//*****************************************GP2D12******************************************

void gp2d12 (void)

{

int16 q;

float d,

v;

TRISB = 0B11110011; // Defines Puerto B como SALIDA=0 y ENTRADA =1 de datos.

TRISC = 0B11111110;

setup_adc_ports(0); // Seleccionamos el Puerto A como entradas Analogicas. Mirar ADCON1.

setup_adc(ADC_CLOCK_INTERNAL); // Fuente de reloj RC interno.

TA4 = 0;

set_adc_channel(0); // HabilitaciOn canal 0 "AN0"

set_adc_channel(1); // HabilitaciOn canal 1 "AN1"

for (;;) // Bucle infinito.

{

delay_ms(20); // Retardo de 20uS necesaria para respetar el tiempo de Adquisicion Tad.

q = read_adc(); // Lectura canal 0 "AN0"

v = (5.0 * q) / 1024.0; // Conversion a tension del codigo digital "q".

d=Gp2d12_v_d(v);

if (d>=8&&d<=30){ // Si la distancia esta comprendida entre 8 cm

// y 30 cm el motor gira hacia adelante.

RB3 = 1;

RB2 = 0;

RA4 = 0;

RC0 = 1;

}

else{ // Si la distancia menor menor de 8 cm o mayor

// de 30 cm el motor para.

RB3 = 0;

RB2 = 0;

RA4 = 0;

RC0 = 0;

}

}

}



10.- Librerías.

10.1.- Servo Futaba 10bit. //CONTROL DE UN SERVOMOTOR DE POSICION DE FUTABA CON PWM UTILIZANDO 10 BIT DE

RESOLUCION

; Con TH=0 corresponde a -90 grados de Posicion del servo

; Con TH=57 corresponde a 0 grados de Posicion del servo

; Con TH=113 corresponde a 90 grados de Posicion del servo

;El microcontrolador PIC 16f876a tiene un harware integrado que puede generar 2 senales PWM

;por las patillas RC2 y RC1.

;El periodo para ambas senales se fija con la siguiente fornula

;T =[(PR2+1)*4*Tosc]*(TMR2_Valor_preescalar)

;El nivel alto T1H se controla con 10 bit ( Los 8 bit mas significativo con el registro CCPR1L y

;los dos bit menos significativos con CCP1X y CCP1Y que estan en el registro CCP1CON)

;Esta senal sale por la patilla RC2.

;El nivel alto T2H se controla con con 10 bit ( Los 8 bit mas significativo con el registro CCPR2L y

;los dos bit menos significativos con CCP2X y CCP2Y que estan en el registro CCP2CON)

;Esta senal sale por la patilla RC1.

;Para refrescar el nivel alto T1H que haber transcurrido un tiempo superior a un periodo "T".

;El Servomotor de Futaba se controla con una senal cuadrada de periodo "T1".

;La posicion del Servomotor lo determina el nivel alto de la senal "T1H"

;El Servomotor de Futaba necesita un periodo "T1" entre 10ms y 30 ms.

;Cargando los registros de forma correcta sale T1 =[(249+1)*4*1uS](16)=16 mS (Cristal de cuarzo 1 MHz)

;Tiene un control de Posicion de -90 Grados < P (Angular)< +90 Grados controlado con T1H.

;Para -90 Grados corresponde un nivel alto T1H = 0,6 ms

;Para 0 Grados corresponde un nivel alto T1H = 1,2 ms

;Para +90 Grados corresponde un nivel alto T1H = 2,4 ms

*/

// ******************************** Declaración de funciones

******************************************

void Inicializacion_Futaba_RC1(); // Inicalizar PWM por RC1

void Inicializacion_Futaba_RC2(); // Inicalizar PWM por RC2

void Futaba_RC1(int16 TH); // Generar PWM por RC1

void Futaba_RC2(int16 TH); // Generar PWM por RC2

//********************************** Igualdades

****************************************************

#define THmin 37 // THmin=37 equivale a 600uS a nivel alto a -90º

#define THmax 150 // THmax=150 equivale a 2400uS a nivel alto a +90º

#define THmed 94 // THmed=94 equivale a 1500uS a nivel alto a 0º

// ************************ Función principal o programa principal **************************************

void Inicializacion_Futaba_RC1()

{

int16 TH;

setup_timer_2(T2_DIV_BY_16,249,1); // setup_timer(Prescaler,PR2,Postscaler)



// Configuración timer2. Si el Periodo = 16mS ----> T = 16000uS

// T = [PR2+1] x Tcm x Postscaler

// PR2 puede valer de 0 a 255.

// Tcm es el tiempo de Ciclo Maquina. Tcm = 4/Fosc = 4/1.000.000 hz = 4uS.

// Prescaler puede valer 1,4,16

// Postscaler puede valer 1.

// 16000uS = [PR2+1] x 1 x 16

// PR2 =[T/(Tcm x Preescaler x Postscaler)]-1

// PR2 =[16000uS/(4uS x 16 x 1)]-1 = 249 (en C 249)

setup_ccp2(CCP_PWM); // CCP2 en modo PWM (Salida por RC1)

TH = THmed;

set_pwm2_duty(TH);

delay_ms(5);

}

void Inicializacion_Futaba_RC2()

{

int16 TH;

setup_timer_2(T2_DIV_BY_16,249,1); // setup_timer(Prescaler,PR2,Postscaler)

// Configuración timer2. Si el Periodo = 16mS ----> T = 16000uS

// T = [PR2+1] x Tcm x Postscaler

// PR2 puede valer de 0 a 255.

// Tcm es el tiempo de Ciclo Maquina. Tcm = 4/Fosc = 4/1.000.000 hz = 4uS.

// Prescaler puede valer 1,4,16

// Postscaler puede valer 1.

// 16000uS = [PR2+1] x 1 x 16

// PR2 =[T/(Tcm x Preescaler x Postscaler)]-1

// PR2 =[16000uS/(4uS x 16 x 1)]-1 = 249 (en C 249)

setup_ccp1(CCP_PWM); // CCP1 en modo PWM (Salida por RC2)

TH = THmed;

set_pwm1_duty(TH);

delay_ms(5);

}

void Futaba_RC1(int16 TH)

{

TH = TH+THmin;

if(TH>THmin && TH<THmax) set_pwm2_duty(TH);

if(TH<=THmin)

{

TH=THmin+1;

set_pwm2_duty(TH);

}

if(TH>=THmax)

{

TH=THmax-1;

set_pwm2_duty(TH);

}

delay_ms(5); // Tiene que transcurrir un tiempo mayor que el periodo de la senal T =16000 us,



// para refrescar el nivel alto de la senal.

// Si utilizamos la funcion delay_ms(5)el tiempos de retardo equivale al

// valor puesto multiplicado por 4 (Estamos utilizando un cristal de 1 MHz).

// es decir 20ms.

}

void Futaba_RC2(int16 TH)

{

TH = TH+THmin;

if(TH>THmin && TH<THmax) set_pwm1_duty(TH);

if(TH<=THmin)

{

TH=THmin+1;

set_pwm1_duty(TH);

}

if(TH>=THmax)

{

TH=THmax-1;

set_pwm1_duty(TH);

}

delay_ms(5); // Tiene que transcurrir un tiempo mayor que el periodo de la senal T =16000 us,

// para refrescar el nivel alto de la senal.

// Si utilizamos la funcion delay_ms(5)el tiempos de retardo equivale al

// valor puesto multiplicado por 4 (Estamos utilizando un cristal de 1 MHz).

// es decir 20ms.

}

10.2.- LCD1.

///////////////////////////////////////////////////////////////////////////////////////////////////////////

//// LCDD.C ////

//// Driver for common LCD modules ////

//// ////

//// lcd_init() Must be called before any other function. ////

//// ////

//// lcd_putc(c) Will display c on the next position of the LCD. ////

//// The following have special meaning: ////

//// \f Clear display ////

//// \n Go to start of second line ////

//// \b Move back one position ////

//// ////

//// lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1) ////

//// ////

//// lcd_getc(x,y) Returns character at position x,y on LCD ////

//// ////

///////////////////////////////////////////////////////////////////////////////////////////////////////////

//// (C) Copyright 1996,2003 Custom Computer Services ////

//// This source code may only be used by licensed users of the CCS C ////

//// compiler. This source code may only be distributed to other ////

//// licensed users of the CCS C compiler. No other use, reproduction ////

//// or distribution is permitted without written permission. ////

//// Derivative programs created using this software in object code ////

//// form are not restricted in any way. ////

///////////////////////////////////////////////////////////////////////////////////////////////////////////



// As defined in the following structure the pin connection is as follows:

// D0 enable

// D1 rs

// D2 rw

// D4 D4

// D5 D5

// D6 D6

// D7 D7

//

// LCD pins D0-D3 are not used and PIC D3 is not used.

// Un-comment the following define to use port B

#define use_portb_lcd TRUE

struct lcd_pin_map { // This structure is overlayed

BOOLEAN enable; // on to an I/O port to gain

BOOLEAN rs; // access to the LCD pins.

BOOLEAN rw; // The bits are allocated from

BOOLEAN unused; // low order up. ENABLE will

int data : 4; // be pin B0.

} lcd;

#if defined(__PCH__)

#if defined use_portb_lcd

#byte lcd = 0xF81 // This puts the entire structure

#else

#byte lcd = 0xF82 // This puts the entire structure

#endif

#else


#byte lcd = 6 // on to port B (at address 6)

#else

#byte lcd = 7 // on to port C (at address 7)

#endif

#endif


#define set_tris_lcd(x) set_tris_b(x)

#else

#define set_tris_lcd(x) set_tris_c(x)

#endif

#define lcd_type 2 // 0=5x7, 1=5x10, 2=2 lines

#define lcd_line_two 0x40 // LCD RAM address for the second line

BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};

// These bytes need to be sent to the LCD

// to start it up.

// The following are used for setting

// the I/O port direction register.

struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out

struct lcd_pin_map const LCD_READ = {0,0,0,0,15}; // For read mode data pins are in

BYTE lcd_read_byte() {

BYTE low,high;

set_tris_lcd(LCD_READ);

lcd.rw = 1;

delay_cycles(1);

lcd.enable = 1;



delay_cycles(1);

high = lcd.data;

lcd.enable = 0;

delay_cycles(1);

lcd.enable = 1;

delay_us(1);

low = lcd.data;

lcd.enable = 0;

set_tris_lcd(LCD_WRITE);

return( (high<<4) | low);

}

void lcd_send_nibble( BYTE n ) {

lcd.data = n;

delay_cycles(1);

lcd.enable = 1;

delay_us(2);

lcd.enable = 0;

}

void lcd_send_byte( BYTE address, BYTE n ) {

lcd.rs = 0;

while ( bit_test(lcd_read_byte(),7) ) ;

lcd.rs = address;

delay_cycles(1);

lcd.rw = 0;

delay_cycles(1);

lcd.enable = 0;

lcd_send_nibble(n >> 4);

lcd_send_nibble(n & 0xf);

}

void lcd_init() {

BYTE i;

set_tris_lcd(LCD_WRITE);

lcd.rs = 0;

lcd.rw = 0;

lcd.enable = 0;

delay_ms(15);

for(i=1;i<=3;++i) {

lcd_send_nibble(3);

delay_ms(5);

}

lcd_send_nibble(2);

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

lcd_send_byte(0,LCD_INIT_STRING[i]);

}

void lcd_gotoxy( BYTE x, BYTE y) {

BYTE address;

if(y!=1)

address=lcd_line_two;

else

address=0;

address+=x-1;

lcd_send_byte(0,0x80|address);



}

void lcd_putc( char c) {

switch (c) {

case '\f' : lcd_send_byte(0,1);

delay_ms(2);

break;

case '\n' : lcd_gotoxy(1,2); break;

case '\b' : lcd_send_byte(0,0x10); break;

default : lcd_send_byte(1,c); break;

}

}

char lcd_getc( BYTE x, BYTE y) {

char value;

lcd_gotoxy(x,y);

while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low

lcd.rs=1;

value = lcd_read_byte();

lcd.rs=0;

return(value);

}

10.3.- KBD1.

///////////////////////////////////////////////////////////////////////////////////////////////////////////

//// KBDD.C ////

//// Generic keypad scan driver ////

//// ////

//// kbd_init() Must be called before any other function. ////

//// ////

//// c = kbd_getc(c) Will return a key value if pressed or /0 if not ////

//// This function should be called frequently so as ////

//// not to miss a key press. ////

//// ////

///////////////////////////////////////////////////////////////////////////////////////////////////////////

//// (C) Copyright 1996,2003 Custom Computer Services ////

//// This source code may only be used by licensed users of the CCS C ////

//// compiler. This source code may only be distributed to other ////

//// licensed users of the CCS C compiler. No other use, reproduction ////

//// or distribution is permitted without written permission. ////

//// Derivative programs created using this software in object code ////

//// form are not restricted in any way. ////

///////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////// The following defines the keypad layout on port D

// Un-comment the following define to use port B

#define use_portb_kbd TRUE

// Make sure the port used has pull-up resistors (or the LCD) on

// the column pins

#if defined(__PCH__)

#if defined use_portb_kbd

#byte kbd = 0xF81 // This puts the entire structure



#else

#byte kbd = 0xF82 // This puts the entire structure

#endif

#else


#byte kbd = 6 // on to port B (at address 6)

#else

#byte kbd = 7 // on to port C (at address 7)

#endif

#endif


#define set_tris_kbd(x) set_tris_b(x)

#else

#define set_tris_kbd(x) set_tris_c(x)

#endif

//Keypad connection: (for example column 0 is B2)

// Bx:

#ifdef blue_keypad ///////////////////////////////////// For the blue keypad

#define COL0 (1 << 2)



#define ROW0 (1 << 4)




#else ////////////////////////////////////////////////// For the black keypad








#endif

#define ALL_ROWS (ROW0|ROW1|ROW2|ROW3)

#define ALL_PINS (ALL_ROWS|COL0|COL1|COL2)

// Keypad layout:

char const KEYS[4][3] = {{'1','2','3'},

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

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

{'*','0','#'}};

#define KBD_DEBOUNCE_FACTOR 33 // Set this number to apx n/333 where

// n is the number of times you expect

// to call kbd_getc each second

void kbd_init() {

}

char kbd_getc( ) {



static BYTE kbd_call_count;

static short int kbd_down;

static char last_key;

static BYTE col;

BYTE kchar;

BYTE row;

kchar='\0';

if(++kbd_call_count>KBD_DEBOUNCE_FACTOR) {

switch (col) {

case 0 : set_tris_kbd(ALL_PINS&~COL0);

kbd=~COL0&ALL_PINS;

break;


kbd=~COL1&ALL_PINS;

break;


kbd=~COL2&ALL_PINS;

break;

}

if(kbd_down) {

if((kbd & (ALL_ROWS))==(ALL_ROWS)) {

kbd_down=FALSE;

kchar=last_key;

last_key='\0';

}

} else {

if((kbd & (ALL_ROWS))!=(ALL_ROWS)) {

if((kbd & ROW0)==0)

row=0;

else if((kbd & ROW1)==0)

row=1;


row=2;


row=3;

last_key =KEYS[row][col];

kbd_down = TRUE;

} else {

++col;

if(col==3)

col=0;

}

}

kbd_call_count=0;

}

set_tris_kbd(ALL_PINS);

return(kchar);

}



10.4.- 16F876.

//////// Standard Header file for the PIC16F876 device ////////////////

#device PIC16F876

#nolist

//////// Program memory: 8192x14 Data RAM: 367 Stack: 8

//////// I/O: 22 Analog Pins: 5

//////// Data EEPROM: 256

//////// C Scratch area: 77 ID Location: 2000

//////// Fuses: LP,XT,HS,RC,NOWDT,WDT,NOPUT,PUT,PROTECT,PROTECT_5%

//////// Fuses: PROTECT_50%,NOPROTECT,NOBROWNOUT,BROWNOUT,LVP,NOLVP,CPD

//////// Fuses: NOCPD,WRT,NOWRT,DEBUG,NODEBUG

////////

////////////////////////////////////////////////////////////////// I/O

// Discrete I/O Functions: SET_TRIS_x(), OUTPUT_x(), INPUT_x(),

// PORT_B_PULLUPS(), INPUT(),

// OUTPUT_LOW(), OUTPUT_HIGH(),

// OUTPUT_FLOAT(), OUTPUT_BIT()

// Constants used to identify pins in the above are:

#define PIN_A0 40

#define PIN_A1 41

#define PIN_A2 42

#define PIN_A3 43

#define PIN_A4 44

#define PIN_A5 45

#define PIN_B0 48

#define PIN_B1 49

#define PIN_B2 50

#define PIN_B3 51

#define PIN_B4 52

#define PIN_B5 53

#define PIN_B6 54

#define PIN_B7 55

#define PIN_C0 56

#define PIN_C1 57

#define PIN_C2 58

#define PIN_C3 59

#define PIN_C4 60

#define PIN_C5 61

#define PIN_C6 62

#define PIN_C7 63

////////////////////////////////////////////////////////////////// Useful defines

#define FALSE 0

#define TRUE 1

#define BYTE int

#define BOOLEAN short int

#define getc getch

#define fgetc getch

#define getchar getch



#define putc putchar

#define fputc putchar

#define fgets gets

#define fputs puts

////////////////////////////////////////////////////////////////// Control

// Control Functions: RESET_CPU(), SLEEP(), RESTART_CAUSE()

// Constants returned from RESTART_CAUSE() are:

#define WDT_FROM_SLEEP 3

#define WDT_TIMEOUT 11

#define MCLR_FROM_SLEEP 19

#define MCLR_FROM_RUN 27

#define NORMAL_POWER_UP 24

#define BROWNOUT_RESTART 26

////////////////////////////////////////////////////////////////// Timer 0

// Timer 0 (AKA RTCC)Functions: SETUP_COUNTERS() or SETUP_TIMER_0(),

// SET_TIMER0() or SET_RTCC(),

// GET_TIMER0() or GET_RTCC()

// Constants used for SETUP_TIMER_0() are:

#define RTCC_INTERNAL 0

#define RTCC_EXT_L_TO_H 32

#define RTCC_EXT_H_TO_L 48

#define RTCC_DIV_1 8









#define RTCC_8_BIT 0

// Constants used for SETUP_COUNTERS() are the above

// constants for the 1st param and the following for

// the 2nd param:

////////////////////////////////////////////////////////////////// WDT

// Watch Dog Timer Functions: SETUP_WDT() or SETUP_COUNTERS() (see above)

// RESTART_WDT()

//

#define WDT_18MS 8

#define WDT_36MS 9

#define WDT_72MS 10

#define WDT_144MS 11





////////////////////////////////////////////////////////////////// Timer 1

// Timer 1 Functions: SETUP_TIMER_1, GET_TIMER1, SET_TIMER1




// (or (via |) together constants from each group)

#define T1_DISABLED 0

#define T1_INTERNAL 0x85

#define T1_EXTERNAL 0x87

#define T1_EXTERNAL_SYNC 0x83

#define T1_CLK_OUT 8

#define T1_DIV_BY_1 0

#define T1_DIV_BY_2 0x10



////////////////////////////////////////////////////////////////// Timer 2

// Timer 2 Functions: SETUP_TIMER_2, GET_TIMER2, SET_TIMER2


#define T2_DISABLED 0




////////////////////////////////////////////////////////////////// CCP

// CCP Functions: SETUP_CCPx, SET_PWMx_DUTY

// CCP Variables: CCP_x, CCP_x_LOW, CCP_x_HIGH

// Constants used for SETUP_CCPx() are:

#define CCP_OFF 0

#define CCP_CAPTURE_FE 4

#define CCP_CAPTURE_RE 5

#define CCP_CAPTURE_DIV_4 6

#define CCP_CAPTURE_DIV_16 7

#define CCP_COMPARE_SET_ON_MATCH 8

#define CCP_COMPARE_CLR_ON_MATCH 9

#define CCP_COMPARE_INT 0xA

#define CCP_COMPARE_RESET_TIMER 0xB

#define CCP_PWM 0xC

#define CCP_PWM_PLUS_1 0x1c



long CCP_1;

#byte CCP_1 = 0x15

#byte CCP_1_LOW= 0x15

#byte CCP_1_HIGH= 0x16

long CCP_2;

#byte CCP_2 = 0x1B

#byte CCP_2_LOW= 0x1B

#byte CCP_2_HIGH= 0x1C

////////////////////////////////////////////////////////////////// SPI

// SPI Functions: SETUP_SPI, SPI_WRITE, SPI_READ, SPI_DATA_IN

// Constants used in SETUP_SSP() are:

#define SPI_MASTER 0x20

#define SPI_SLAVE 0x24

#define SPI_L_TO_H 0

#define SPI_H_TO_L 0x10

#define SPI_CLK_DIV_4 0



#define SPI_CLK_T2 3

#define SPI_SS_DISABLED 1



#define SPI_SAMPLE_AT_END 0x8000

#define SPI_XMIT_L_TO_H 0x4000

////////////////////////////////////////////////////////////////// UART

// Constants used in setup_uart() are:

// FALSE - Turn UART off

// TRUE - Turn UART on

#define UART_ADDRESS 2

#define UART_DATA 4

////////////////////////////////////////////////////////////////// ADC

// ADC Functions: SETUP_ADC(), SETUP_ADC_PORTS() (aka SETUP_PORT_A),

// SET_ADC_CHANNEL(), READ_ADC()

// Constants used for SETUP_ADC() are:

#define ADC_OFF 0 // ADC Off

#define ADC_CLOCK_DIV_2 0x100



#define ADC_CLOCK_INTERNAL 0xc0 // Internal 2-6us

// Constants used in SETUP_ADC_PORTS() are:

#define NO_ANALOGS 7 // None

#define ALL_ANALOG 0 // A0 A1 A2 A3 A5

#define AN0_AN1_AN2_AN4_VSS_VREF 1 // A0 A1 A2 A5 VRefh=A3

#define AN0_AN1_AN3 4 // A0 A1 A3

#define AN0_AN1_VSS_VREF 5 // A0 A1 VRefh=A3

#define AN0_AN1_AN4_VREF_VREF 0x08 // A0 A1 A5 VRefh=A3 VRefl=A2

#define AN0_AN1_VREF_VREF 0x0D // A0 A1 VRefh=A3 VRefl=A2

#define AN0 0x0E // A0

#define AN0_VREF_VREF 0x0F // A0 VRefh=A3 VRefl=A2

#define ANALOG_RA3_REF 0x1 //!old only provided for compatibility

#define RA0_RA1_RA3_ANALOG 0x4 //!old only provided for compatibility

#define RA0_RA1_ANALOG_RA3_REF 0x5 //!old only provided for compatibility

#define ANALOG_RA3_RA2_REF 0x8 //!old only provided for compatibility

#define RA0_RA1_ANALOG_RA3_RA2_REF 0xD //!old only provided for compatibility

#define RA0_ANALOG 0xE //!old only provided for compatibility

#define RA0_ANALOG_RA3_RA2_REF 0xF //!old only provided for compatibility

// Constants used in READ_ADC() are:

#define ADC_START_AND_READ 7 // This is the default if nothing is specified

#define ADC_START_ONLY 1

#define ADC_READ_ONLY 6

////////////////////////////////////////////////////////////////// INT

// Interrupt Functions: ENABLE_INTERRUPTS(), DISABLE_INTERRUPTS(),

// EXT_INT_EDGE()

//

// Constants used in EXT_INT_EDGE() are:

#define L_TO_H 0x40

#define H_TO_L 0

// Constants used in ENABLE/DISABLE_INTERRUPTS() are:

#define GLOBAL 0x0BC0



#define INT_RTCC 0x0B20

#define INT_RB 0x0B08

#define INT_EXT 0x0B10

#define INT_AD 0x8C40

#define INT_TBE 0x8C10

#define INT_RDA 0x8C20

#define INT_TIMER1 0x8C01

#define INT_TIMER2 0x8C02

#define INT_CCP1 0x8C04

#define INT_CCP2 0x8D01

#define INT_SSP 0x8C08

#define INT_BUSCOL 0x8D08

#define INT_EEPROM 0x8D10

#define INT_TIMER0 0x0B20

#list

10.5.- Driver GP2D12

// DRIVER DE CONTROL DEL SENSOR DE DISTANCIA Gp2d12, para una recta entre 10 cm y 55 cm.

// HACE LA CONVERISON DE TENSION PROCEDENTE DEL SENSOR Gp2d12 A UNA DISTANCIA (SE

// OBTIENE UNA DISTANCIA EN FUNCION DE LA TENSIÓN).

// SE INTRODUCE UN VALOR DE TENSIÓN (v)TIPO FLOAT Y DEVUELVE UNA DISTANCIA (d)FLOAT.

//************************** DECLARACIÓN DE FUNCIONES***********************************

float Gp2d12_v_d(float);

//*************************FUNCIÓN Gp2d12_v_d**********************************************

float Gp2d12_v_d(float v){

float l;

l=0;

if(v>2.6)

l = 8;

if(v<2.6&&v>=1.9)

l = 13.5 + ((8-13.5)* (v - 1.9) /(2.6-1.9));

if(v<1.9&&v>=1.65)

l = 16 + ((13.5-16)* (v- 1.65) / (1.9-1.65));

if(v<1.65&&v>=1.38)

l = 20 + ((16-20)* (v- 1.38) / (1.65-1.38));

if(v<1.38&&v>=1.15)

l = 25 + ((20-25)* (v- 1.15) / (1.38-1.15));

if(v<1.15&&v>=0.95)

l = 30 + ((25-30)* (v- 0.95) / (1.15-0.95));

if(v<0.95&&v>=0.75)

l = 40 + ((30-40)* (v- 0.75) / (0.95-0.75));

if(v<0.75&&v>=0.68)

l = 45 + ((40-45)* (v- 0.68) / (0.75-0.68));

if(v<0.68&&v>=0.58)

l = 55 + ((45-55)* (v- 0.58) / (0.68-0.58));

if(v<0.58)

l=55;

return(l);

}

proyectopedrojoanmiro.webcindario.com/desarrollo_de_proyectos/proyectos... · proyecto...

Documents