Documentos de Académico
Documentos de Profesional
Documentos de Cultura
ROBOT-MINISUMO
Departamento de Electricidad-Electrnica
ndice: Pgina
ndice: Pgina
10.- Libreras.
10.1.- Servo Futaba 10bit.
10.2.- LCD1.....
10.3.- KBD1.
10.4.- 16F876..
1.- Introduccin
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 misin, como su nombre lo indica, de luchar con otros robots similares
en peso y tamao, 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 tcnicas digitales que tiene como ncleo 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.
Adems, el robot fue diseado para poder ser controlado como coche teledirigido.
En todo momento el control del robot puede hacerse manualmente.
Existe una comunicacin entre el robot y un mando en radio frecuencia con los mdulos de
CEBECK C-0503 y C-0504. Que son un transmisor y receptor de datos en modulacin AM
que trabajan a una frecuencia portadora 433,92 MHz y tienen un Ancho de Banda de 4 KHz.
El diseo 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 programacin del PIC 16F876A hemos utilizado una herramienta llamada PIC C
Compiler.
Y para terminar, de esta Fuente de Alimentacin obtenemos una tensin de 8.4V para la
alimentacin de los motores ya que 5v no es una tensin suficiente para el funcionamiento de los
motores.
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 seales, por lo general las ms usadas son;
TX, RX, RTS, CTS, estas dos ltimas son las usadas para el protocolo handshaking (Protocolo de
comienzo de comunicacin entre dos mquinas o sistemas) pero no es imprescindible su uso. Para
que el MAX232 funcione correctamente deberemos de poner unos condensadores externos de 1F.
5 GND - Masa
6 DSR In Dispositivo de Datos
Listo
9 RI In Indicador de llamada
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.
As podemos ver que poniendo a nivel alto la entrada de habilitacin "EN", la salida de este "OUT"
pasa de alta impedancia al mismo nivel que se encuentre la entrada "IN" pero amplificado en
tensin y en corriente, siendo esta de 1A mximo.
En este diseo colocamos optoacopladores en la salida de cada una de las entradas del L293B
porque al inicio del arranque del motor, este demanda ms 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 parmetros, pueden llegar a daar su estructura y funcionalidad.
Sensor que mide distancia mediante triangulacin con PSD (Detector Sensible a la Posicin), Led
infrarrojo y circuito de procesado de seal, valor nominal entre 0 y 3V dependiendo de la distancia.
La informacin 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 pequeo, el objeto est lejos, por lo
que el tringulo formado es estrecho.
El LED infrarrojo emite el haz de luz a travs de una pequea lente convergente que hace que el haz
emisor llegue de forma paralela al objeto. Cuando la luz choca con un obstculo, una cierta cantidad
de luz se refleja, casi todas las sustancias tienen un grado bastante grande de rugosidad de la
superficie que produce una dispersin hemisfrica de la luz (la llamada reflexin no terica).
Alguno de estos haces de esta luz rebota hacia el sensor que es recibido por la lente. La lente
receptora tambin es una lente convexa. Acta para convertir el ngulo de posicin. 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
tambin enfocan a este punto.
Caractersticas:
1. Menos influencia del color de los objetos reflexivos
2. Lnea indicadora de distancia output/distance :
Tipo de salida indicadora de la distancia analgica (tensin analgica) para el GP2D12.
Distancia del detector de 10 a 80 cm.
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.
El acondicionador de seal 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 tensin 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 histresis.
Se ha utilizado este microcontrolador, ya que el robot est diseado para controlar varios perifricos
(motores, servomotores, sensores infrarrojos y sensores pticos, radio frecuencia, cargador del
programa controlador, etc) y es necesario muchas lneas de entrada y salida. Este microcontrolador
dispone de los elementos necesarios para controlar los sensores y motores como los Timers,
convertidores de analgica a digital, salidas de control por PWM.
El microcontrolador PIC 16F876A trabaja a una frecuencia de 1 MHz y ejecuta una instruccin en
1s.
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.
El mando tiene la misin de transmitir un cdigo asociado a cada pulsador, para poder controlar el
robot.
El microcontrolador PIC 16F876a lee los pulsadores y transmite los cdigos va serie a la tarjeta
transmisora de radiofrecuencia a una velocidad de 1562,5 baudios por segundo. Es una transmisin
asncrona (1bit de comienzo, 8bit de Datos, 1 bit de parada sin bit de paridad).
El TRT Q1E tiene la misin 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 hbrido
encargado de transmitir va radiofrecuencia, los datos digitales procedentes del microprocesador
(TX). La seal 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 instruccin en
1s.
El Led D7E nos indica que el mando est encendido, est limitada su corriente en 20 mA.
Mando
VDD
U2E
D6E SW6E 7805_JOAN Q1E E_RF1E
1 2 1 3 BD136_JOAN
VI VO
A K INTERRUPTOR_JOAN
Emisor de Datos CEBEK C-0503
GND
1N4007_JOAN
1
R6E
BAT1E C2E 220
Antena
2
C1E
GND3
GND2
GND1
9V 220uF
2
Vcc
R7E
Ve
220uF
-
VSS
2.2k
A
15
13
11
D7E
LED-RED_JOAN CON1E
1
K
BORNIER1_JOAN
C3E
15pF
U1E
RB0E 21 9
RB0/INT OSC1/CLKIN
RB1E 22 10
RB1 OSC2/CLKOUT
R1E R2E R3E R4E R5E RB2E 23 1
RB2 MCLR/Vpp/THV VDD
RB3E 24 X1E
220 220 220 220 220 RB3/PGM
RB4E 25 2
RB4 RA0/AN0
26 3 4MHz
RB5 RA1/AN1
27 4
A
13
RC2/CCP1
14
RC3/SCK/SCL
15
RC4/SDI/SDA
16
RC5/SDO
RB1E RB3E RB0E RB2E RB4E 17
RC6/TX/CK
18
RC7/RX/DT
1
PIC16F876_JOAN
SW1E SW2E SW3E SW4E SW5E
2
5.3.- Control.
5.3.1.- Esquema Elctrico.
5.4.- Mando.
5.4.1.- Esquema Elctrico.
Mando
VDD
U2E
D6E SW6E 7805_JOAN Q1E E_RF1E
1 2 1 3 BD136_JOAN
VI VO
A K INTERRUPTOR_JOAN
Emisor de Datos CEBEK C-0503
GND
1N4007_JOAN
1
R6E
BAT1E C2E 220
Antena
C1E 2
GND3
GND2
GND1
9V 220uF
2
Vcc
R7E
Ve
220uF
-
VSS
2.2k
15
13
11
1
D7E
LED-RED_JOAN CON1E
1
K
BORNIER1_JOAN
C3E
15pF
U1E
RB0E 21 9
RB0/INT OSC1/CLKIN
RB1E 22 10
RB1 OSC2/CLKOUT
R1E R2E R3E R4E R5E RB2E 23 1
RB2 MCLR/Vpp/THV VDD
RB3E 24 X1E
220 220 220 220 220 RB3/PGM
RB4E 25 2
RB4 RA0/AN0
26 3 4MHz
RB5 RA1/AN1
27 4
A
13
RC2/CCP1
14
RC3/SCK/SCL
15
RC4/SDI/SDA
16
RC5/SDO
RB1E RB3E RB0E RB2E RB4E 17
RC6/TX/CK
18
RC7/RX/DT
1
PIC16F876_JOAN
SW1E SW2E SW3E SW4E SW5E
2
28 Resistencias
12 Condensadores
10 Circuitos Integrados.
85 Componentes diversos.
6.2.- Mando.
Ttulo: Mando.DSN
Autor: Pedro Alonso Sanz, Alfonso Garca Gallego, Juan Dongil Garca
Revisin:
Creado: mircoles, 16 de febrero de 2005
Ultima modificacin: viernes, 08 de febrero de 2008
Nmero de Componentes: 49
7 Resistencias.
4 Condensadores.
2 Circuitos Integrados.
1 Transistor.
7 Diodos.
28 Componentes diversos.
Coste 20 / Hora.
7.2.- Material.
8.- Referencias.
[2] Libro: Ttulo: Compilador C CCS y Simulador Proteus para Microcontroladores PICC
Autor: Eduardo Garca Breijo
Editorial: marcombo
#include <16F876A.h>
#FUSES XT,NOWDT
#use delay(clock=4000000)
while (true)
{
RB2 = 0; // Motor parado.
RB3 = 0;
RA4 = 0;
RC0 = 0;
delay_ms(500); // Retardo 500 ms.
#include <16F876A.h>
#FUSES XT,NOWDT
#use delay(clock=4000000)
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;
}
TH = 41;
Futaba_RC2(TH); // Posicionar el Servo de la patilla RC2.
delay_ms(1000);
TH = 57;
Futaba_RC2(TH); // Posicionar el Servo de la patilla RC2.
delay_ms(1000);
TH = 73;
Futaba_RC2(TH); // Posicionar el Servo de la patilla RC2.
delay_ms(1000);
TH = 100;
Futaba_RC2(TH); // Posicionar el Servo de la patilla RC2.
delay_ms(2000);
TH = 41;
Futaba_RC2(TH); // Posicionar el Servo de la patilla RC2.
delay_ms(1000);
TH = 25;
Futaba_RC2(TH); // Posicionar el Servo de la patilla RC2.
delay_ms(1000);
}
}
#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
#use delay(clock=4000000)
//*******************************PROGRAMA PRINCIPAL****************************************
void main()
{
int16 q;
float d,
v;
#include <16F876A.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
#use delay(clock=1000000)
while (1)
{
if(RB5==1|RB6==1){ //Si RB5 = 1 o RB6 = 1 motores atrs
RB2 = 1;
RB3 = 0;
RA4 = 1;
RC0 = 0;
}
else{ // Sino motores adelante
RB2 = 0;
RB3 = 1;
RA4 = 0;
RC0 = 1;
}
}
}
#FUSES XT,NOWDT
#use delay(clock=1000000)
}
}
}
#FUSES XT,NOWDT
#use delay(clock=1000000)
#include <driver_gp2d12.c>
TRISA = 0B11101111;
TRISB = 0B11110011;
TRISC = 0B11111110;
enable_interrupts(int_rb); // Habilitamos la interrupcin por cambio de nivel de RB4, RB5, RB6, RB7.
RC0 = 0;
}
while(RB4==1|RB7==1){ // Interrupcin 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;
d=Gp2d12_v_d(v);
10.- Libreras.
;El microcontrolador PIC 16f876a tiene un harware integrado que puede generar 2 senales PWM
;por las patillas RC2 y RC1.
;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"
;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.
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)
// Configuracin 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)
TH = THmed;
set_pwm1_duty(TH);
delay_ms(5);
}
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,
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. ////
///////////////////////////////////////////////////////////////////////////////////////////////////////////
#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
#if defined use_portb_lcd
#byte lcd = 6 // on to port B (at address 6)
#else
#byte lcd = 7 // on to port C (at address 7)
#endif
#endif
#if defined use_portb_lcd
#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
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);
}
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]);
}
if(y!=1)
address=lcd_line_two;
else
address=0;
address+=x-1;
lcd_send_byte(0,0x80|address);
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. ////
///////////////////////////////////////////////////////////////////////////////////////////////////////////
#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
#if defined use_portb_kbd
#byte kbd = 6 // on to port B (at address 6)
#else
#byte kbd = 7 // on to port C (at address 7)
#endif
#endif
#if defined use_portb_kbd
#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:
#endif
// Keypad layout:
char const KEYS[4][3] = {{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}};
void kbd_init() {
}
char kbd_getc( ) {
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;
case 1 : set_tris_kbd(ALL_PINS&~COL1);
kbd=~COL1&ALL_PINS;
break;
case 2 : set_tris_kbd(ALL_PINS&~COL2);
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;
else if((kbd & ROW2)==0)
row=2;
else if((kbd & ROW3)==0)
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.
#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
////////////////////////////////////////////////////////////////// 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_DIV_2 0
#define RTCC_DIV_4 1
#define RTCC_DIV_8 2
#define RTCC_DIV_16 3
#define RTCC_DIV_32 4
#define RTCC_DIV_64 5
#define RTCC_DIV_128 6
#define RTCC_DIV_256 7
#define RTCC_8_BIT 0
////////////////////////////////////////////////////////////////// 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
#define WDT_288MS 12
#define WDT_576MS 13
#define WDT_1152MS 14
#define WDT_2304MS 15
////////////////////////////////////////////////////////////////// Timer 1
// Timer 1 Functions: SETUP_TIMER_1, GET_TIMER1, SET_TIMER1
// Constants used for SETUP_TIMER_1() are:
#define T1_CLK_OUT 8
#define T1_DIV_BY_1 0
#define T1_DIV_BY_2 0x10
#define T1_DIV_BY_4 0x20
#define T1_DIV_BY_8 0x30
////////////////////////////////////////////////////////////////// Timer 2
// Timer 2 Functions: SETUP_TIMER_2, GET_TIMER2, SET_TIMER2
// Constants used for SETUP_TIMER_2() are:
#define T2_DISABLED 0
#define T2_DIV_BY_1 4
#define T2_DIV_BY_4 5
#define T2_DIV_BY_16 6
////////////////////////////////////////////////////////////////// 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
#define CCP_PWM_PLUS_2 0x2c
#define CCP_PWM_PLUS_3 0x3c
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_DIV_16 1
#define SPI_CLK_DIV_64 2
#define SPI_CLK_T2 3
#define SPI_SS_DISABLED 1
////////////////////////////////////////////////////////////////// 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_DIV_8 0x40
#define ADC_CLOCK_DIV_32 0x80
#define ADC_CLOCK_INTERNAL 0xc0 // Internal 2-6us
////////////////////////////////////////////////////////////////// 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
// 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 TENSIN).
// SE INTRODUCE UN VALOR DE TENSIN (v)TIPO FLOAT Y DEVUELVE UNA DISTANCIA (d)FLOAT.
//*************************FUNCIN 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);
}