Memoria Rastreador - pedrojoanmiro.webcindario.com · Esquema eléctrico de simulación con Proteus ... suavizan el arranque y paro de motores. ... El integrado L298 es un inversor

Memoria Rastreador

Sergio Alonso Torija 15-3-2009 D.P.E. 21

2

I.E.S. Joan Miró (S.S. De los Reyes)

Departamento de Electricidad-Electrónica

Inicio 1.- Explicación breve del Proyecto....................................................... Pág. 3 2.- Diagrama en Bloques del Robot Rastreador................................ Pág. 4 3.- Análisis de los Bloques...................................................................... Pág. 5 3.1.- Alimentación.......................................................................... Pág. 5 3.2.- Sensores................................................................................... Pág. 8 3.3.- Potencia................................................................................... Pág. 9 3.4.- Control..................................................................................... Pág. 14 4.- Esquema eléctrico de simulación con Proteus.............................. Pág. 16 5.- Programas Robot Rastreador........................................................... Pág. 17 5.1.- Librería PIC16F876A............................................................. Pág. 17 5.2.- Librería LCD1.......................................................................... Pág. 23 5.3.- Programa de prueba de motores........................................ Pág. 26 5.4.- Programa de prueba del LCD.............................................. Pág. 28 5.5.- Programa de prueba de sensores....................................... Pág. 30 5.6.- Programa rastreador............................................................. Pág. 33 6.- Diseño de Placas de Circuitos Impresos.......................................... Pág. 45 6.1.- Placa de Alimentación........................................................... Pág. 45 6.2.- Placa de Sensores................................................................... Pág. 46 6.3.- Placa de Potencia................................................................... Pág. 47 6.4.- Placa de Control..................................................................... Pág. 48 7.- Diseño mecánico................................................................................. Pág. 49 8.- Lista componentes y precios............................................................. Pág. 50

3



1.- Explicación breve del Proyecto. El proyecto consiste en diseñar un Microrobot rastreador de forma autónoma y a su vez que pueda ser teledirigido. Este microrobot se ha diseñado pensando en la prueba de rastreadores del concurso de Madridbot. Consta de una plancha sólida de PVC donde sostener todo el robot, esta base se mantiene sobre dos ruedas motrices con movimientos independientes y una rueda loca. La electrónica del proyecto está dividida en 4 Placas de circuito impreso que son: sensores, control, alimentación y potencia. Estas tres últimas tienen idénticas dimensiones con taladros a las mismas medidas pudiendo con separadores de 2,5cm colocar una encima de otra, así, queda formado un bloque de tres pisos sujeto en la base de PVC. La paca de sensores queda agarrada por debajo de la base de tal forma que entre el suelo recto y los sensores de infrarrojos quede una distancia de 3mm. Si trabaja de manera autómata, el microrobot sigue una línea negra sobre un fondo blanco, en caso de bifurcaciones hay una pequeña marca negra a un lado de la línea, esto indica que en la bifurcación el camino que sigue corresponde al lado donde encontró la marca. En modo teledirigido el microrobot podrá moverse en la dirección seleccionada desde un mando inalámbrico. Funciona mediante una tensión de entrada en corriente continua de +7Vcc, como tensión mínima y una tensión máxima de entrada de + 12Vcc. La tensión de entrada influye directamente en la velocidad de los motores, sin embargo, hay componentes de la familia TTL por lo que ha sido necesaria una transformación a 5 voltios de esto se ocupa la placa de alimentación. El consumo de corriente total está entre 100mA y 500mA dependiendo de varios factores, en su mayoría los motores

2.- Diagrama en Bloques del Robot Rastreador.

Cada bloque de los que se visualizan en la imagen corresponde a una placa de circuito impreso. Para las conexiones entre placas se ha utilizado una faja de 10 cables.

3.- Análisis de los Bloques. 3.1.- Alimentación.

Dentro del bloque de ADAPTADOR DE SEÑALES PC-UC REGULADOR 9V/5V encontramos el circuito encargado de dos funciones:

Se alimenta la placa de alimentación a una tensión entre 7 V y 12 V normalmente conectado a una pila de 9 V, y un regulador de tensión se ocupa de una salida fija de 5V que se utiliza para alimentar todos los circuitos integrados TTL.

Contiene un interruptor que interrumpe toda la alimentación del microrobot. El integrado LM350K se le alimenta entre 1,7 y 30V con un máximo de 3A, pero en este autómata conectaremos una pila de 9 V. A la salida obtenemos una tensión de salida que depende del potenciómetro RV1, nos interesa una salida fija de +5V, así que, ajustamos hasta obtener +5 V, esta tensión hace lucir el diodo led D3 y se lleva al conector J1A que conecta el otro extremo con la placa de control. Los condensadores actúan como filtros en la entrada y salida del LM350K y este, queda protegido de corrientes inversas con el diodo D2.

6



En el momento de cargar un programa, la comunicación entre la placa de control y un ordenador se produce mediante el circuito integrado MAX232 que recibe información de un puerto serie y adapta los niveles RS232/TTL incluido en la placa de alimentación.

7



Los condensadores que están conectados al integrado tienen todos ellos una capacidad de 1 µF que es lo que el fabricante aconseja para su correcto funcionamiento según muestra la tabla de la página anterior. Las señales lógica RS-232 tienen la siguiente forma:

Como ejemplo enviamos la palabra “V” en código ASCII.

8



3.2.- Sensores.

La placa de sensores contiene 5 sensores infrarrojos CNY70. Su funcionamiento consiste en un emisor de infrarrojos y un fototransistor (receptor). Sobre una superficie blanca o reflectante el fototransistor recibe mejor los infrarrojos del emisor, por lo que, conducirá mejor.

9



Como en el colector de ceda sensor hay una puerta lógica not o negadora (circuito integrado 74HC14), la tensión que en cada momento tiene el colector la representa como un determinado nivel lógico y a continuación invierte ese nivel lógico.

Tabla de verdad puerta NOT

Entrada A Salida

0 1

1 0

Llega un nivel lógico 1 al conector J5A si el sensor se encuentra sobre una superficie blanca o reflectante, ya que, el foto transistor se satura y en el colector habrá una tensión cerca de 0 V que se lleva a la entrada de una puerta negadora, esta puerta considera esta tensión como un 0 lógico y lo invierte a un 1 lógico (5 V). Llega al conector J5A un nivel lógico 0 si el sensor está posicionado sobre una superficie negra o poco reflectante, puesto que, el foto transistor actúa en corte y en el colector habrá una tensión cercana a 5 V que se lleva a la entrada de una puerta negadora, esta puerta representa esta tensión como un 1 lógico y lo invierte a un 0 lógico (0 V). Las resistencias impares del dibujo de la página anterior, todas ellas de 220 Ω, limitan la tensión del emisor de infrarrojos para garantizar su buen funcionamiento. Las resistencias pares, todas de 18k Ω de valor óhmico, se utilizan en el colector para ajustar la sensibilidad del sensor. El conector J5A une las placas de sensores y de control. 3.3.- Potencia. La placa de potencia tiene una parte de pequeño voltaje y baja corriente (parte de control), mientras que otra parte tiene mayor tensión y gran intensidad (parte de potencia). Las dos partes están separadas eléctricamente. Cada parte tiene su propia masa y su propia alimentación, VDD1 es la salida del regulador que nos da 5 V y V1P el la entrada del regulador conectado a una pila de 9 V.

U3 hasta U8 son octoacopladores, su función es el aislamiento eléctrico. Se basa en un diodo LED emisor de luz y un fototransistor dentro de un encapsulado cuando el LED luce el fototransistor se satura. En el esquema de la página anterior las resistencias impares son de 220 Ω, conectadas en serie con los ánodos de los LED y en el otro extremo 5 V del regulador, así, establece una corriente en los LED, el cátodo está conectado directamente al microcontrolador que manda tensiones de 0 V (nivel lógico 0) y 5 V (nivel lógico 1). De tal manera que, si hay diferencia de potencial entre el ánodo y el cátodo (caso que se da si el microcontrolador manda un N.L. 0) ese LED emite luz, saturando el fototransistor y haciendo llegar 0 V a la entrada del integrado L298, en el caso de U7 y U8 hacen llegar 0 V a los habilitadores (enable). El otro caso, un N.L.1 a la entrada del L298 se produce cuando el microcontrolador manda un N.L. 1, en ese LED no hay diferencia de potencial, no luce, el fototransistor trabaja en modo corte. A la entrada del L298 le llegan 5 V de las resistencias pares del dibujo conectadas en serie. JUMPER1 y JUMPER 2 se han colocado como opción de alimentación para los motores, o 5 V, o 9 V. MIZ y MDE son motores de corriente continua, si existe una diferencia de potencial entre extremos, girarán en un sentido o en el contrario dependiendo de en que sentido se produzca la diferencia de potencial. Si no existe diferencia de potencial entre extremos del motor, este no girará. Los condensadores C10 y C11 quedan colocados en paralelo, de tal forma que, suavizan el arranque y paro de motores. Los 4diodos colocados a los extremos de cada motor se utilizan para evitar tensiones negativas o picos de excesiva tensión producidas en el momento de arranque y paro de motor. El conector J3A une las placas de potencia y de control. El integrado L298 es un inversor de giro, según las entradas el motor girará en un sentido o en otro. Se alimenta a 5 V y tiene su masa de 5V, aparte otra patilla de alimentación VS, que es la alimentación de los motores que va a ser 9 V y las patillas SENSA y SENSB que son las masas de cada motor. A para el motor colocado en OUT1 y OUT2 , y B para el motor colocado en OUT3 y OUT4. ENA y ENB son las habilitaciones de cada motor, llevadas estas patillas a 5 V habilitamos siempre los dos motores. Mediante los octoacopladores U7 y U8 se va a controlar su habilitación, pues solo si el microcontrolador manda un N.L. 1 los transistores se saturan y permiten paso de corriente del motor con su masa.

13



Si SENSA o SENSB están habilitadas su correspondiente motor se habilita y puede comportarse de distintas formas dependiendo de las entradas IN1 e IN2 para el motor A ,e IN3 e IN4 para el motor B:

Entradas a N.L. 00: No gira el motor, no hay diferencia de potencial, pues en cada extremo hay 0 V.

Entradas a N.L. 11: El motor no gira, no hay diferencia de potencial, pues en cada extremo hay 9 V.

Entradas a N.L. 01: Gira el motor, hay diferencia de potencial de 9 V, pues en un extremo hay 0 V y en el otro 9 V.

Entradas a N.L. 10: El motor gira en sentido contrario a la opción anterior, hay diferencia de potencial de 9 V, pues en un extremo hay 9 V y en el otro 0 V.

3.4.- Control.

En la placa de control es en donde se encuentra el microcontrolador que almacena el software y lo ejecuta, a la vez que, envía señales y recibe señales.

Cada conector va a una placa J3 conecta con J3A de la placa de potencia, J5 conecta con J5A de la placa de sensores y J1 conecta con J1A de la placa de alimentación. RF1 es una tarjeta receptora de radiofrecuencia, se le conecta una antena y los datos recibidos los envía por Vs al microcontrolador por RC7. LCD1 es una pantalla que está conectada al puerto B del microcontrolador, su función es la de visualizar mensajes que estén en el programa. La pantalla posee 2 Líneas por 16 caracteres.

Consumo de 7,5 mW.

Representa caracteres ASCII.

Desplaza los caracteres a derecha e Izquierda.

Memoria de 40 caracteres por línea de pantalla, visualizando 16 caracteres por línea..

Se pueden programar 8 caracteres.

Se puede gobernar de 2 formas diferentes: o Conexión con un bus de 4 bits. o Conexión con un bus de 8Bits.

J6, J7, J8, J9 son jumper para una posible utilización de I2C. X1 es un cristal de cuarzo que junto a los condensadores C13 y C16 dan la señal de reloj por la que el microcontrolador se va a regir de 4 Mhz. La patilla 1 del microcontrolador tiene una resistencia en serie con un pulsador, una resistencia y un condensador. Mientras no se pulse el pulsador va a actuar modo circuito abierto a la patilla 1 le va a llegar 5 V provenientes de R26. Si se cierra el pulsador en la patilla 1 habrá 0 V, el integrado reinicia el programa si detecta 0 V en esa patilla. El condensador evita rebotes del pulsador. Inicio es un pulsador colocado a la patilla RA0 si se pulsa pone 0 V

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

5.- Programas Robot Rastreador. Los programas del robot son escritos en el lenguaje C de programación. 5.1.- Librería PIC16F876A. Librería necesaria para trabajar con el microcontrolador. //////// Standard Header file for the PIC16F876A device //////////////// #device PIC16F876A #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,DEBUG,NODEBUG ////////Fuses: //NOPROTECT,NOBROWNOUT,BROWNOUT,LVP,NOLVP,CPD,NOCPD,WR//T_50% //////// Fuses: NOWRT,WRT_25%,WRT_5% //////// ////////////////////////////////////////////////////////////////// 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

18



#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_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

19



#define RTCC_DIV_128 6 #define RTCC_DIV_256 7 #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 #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: // (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 #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

20



// 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 #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 ////////////////////////////////////////////////////////////////// COMP // Comparator Variables: C1OUT, C2OUT // Constants used in setup_comparator() are:

21



#define A0_A3_A1_A3 0xfff04 #define A0_A3_A1_A2_OUT_ON_A4_A5 0xfcf03 #define A0_A3_A1_A3_OUT_ON_A4_A5 0xbcf05 #define NC_NC_NC_NC 0x0ff07 #define A0_A3_A1_A2 0xfff02 #define A0_A3_NC_NC_OUT_ON_A4 0x9ef01 #define A0_VR_A1_VR 0x3ff06 #define A3_VR_A2_VR 0xcff0e #bit C1OUT = 0x9c.6 #bit C2OUT = 0x9c.7 ////////////////////////////////////////////////////////////////// VREF // Constants used in setup_vref() are: #define VREF_LOW 0xa0 #define VREF_HIGH 0x80 // Or (with |) the above with a number 0-15 #define VREF_A2 0x40 ////////////////////////////////////////////////////////////////// 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 0x10000 #define ADC_CLOCK_DIV_4 0x4000 #define ADC_CLOCK_DIV_8 0x0040 #define ADC_CLOCK_DIV_16 0x4040 #define ADC_CLOCK_DIV_32 0x0080 #define ADC_CLOCK_DIV_64 0x4080 #define ADC_CLOCK_INTERNAL 0x00c0 // 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

22



#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 #define INT_COMP 0x8D40 #list

23



5.2.- Librería LCD1. Librería necesaria para trabajar con el LCD #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 #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 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.

24



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);

25



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);

26



5.3.- Programa de prueba de motores.

//********************** Mover el motor izquierdo ********************** #include <16F876A.h> #include <LCD1.c> // Incluimos el driver LCD1.c que contiene las

//funciones de control del LCD. #FUSES XT,NOWDT #use delay(clock=4000000)

27



#BYTE TRISA = 0x85 // TRISC en 85h. #BYTE portA = 0x05 // PORTC en 05h. #BYTE TRISC = 0x87 // TRISC en 87h. #BYTE portC = 0x07 // PORTC en 07h. #BIT RA4 = 0x05.4 // RA4 en 0x05 patilla 4. #BIT RC0 = 0x07.0 // RC0 en 0x07 patilla 0. #BIT VSENSA = 0x07.1 // VSENSA en 0x07 patilla 1. #BIT VSENSB = 0x07.2 // VSENSB en 0x07 patilla 2. #BIT RC5 = 0x07.5 // RC5 en 0x07 patilla 5. #BIT RC6 = 0x07.6 // RC6 en 0x07 patilla 6. void main() TRISC = 0B00000000; // Defines Puerto C como SALIDA de datos. TRISB = 0B00000000; // Defines Puerto B como SALIDA de datos. TRISA = 0B00101111; // Defines las patillas del Puerto A. VSENSA = 1; enable_interrupts(int_rb); // Habilitamos la interrupción por cambio

//de nivel de RB4, RB5, RB6, RB7. enable_interrupts(GLOBAL); // Habilitamos la Interrupción General. while(1) RA4 = 0; RC5 = 0; delay_ms(2000); RA4 = 0; RC5 = 1; delay_ms(2000); RA4 = 1; RC5 = 0; delay_ms(2000); RA4 = 1; RC5 = 1; delay_ms(2000);

28



Este software consiente en lo siguiente: El valor que demos a las patillas RA4 y RC5 se verá reflejado en las entradas IN1 e IN2 del inversor de giro. Primero el motor no gira: RA4 = 0; RC5 = 0;

Hay un retardo de 2 segundos a la siguiente instrucción: delay_ms(2000);

Después el motor gira durante dos segundos: RA4 = 0; RC5 = 1; delay_ms(2000); A continuación el motor cambia el sentido de giro durante dos segundos: RA4 = 1; RC5 = 0; delay_ms(2000); Por último el motor se para 2 segundos: RA4 = 1; RC5 = 1; delay_ms(2000); Una vez terminado comienza de nuevo desde el principio ya que hay una función while (1); este engloba la parte del motor que hace un bucle que se repite sin final. 5.4.- Programa de prueba del LCD.

29



//******************** Mostrar mensajes en el LCD ********************** #include <16F876A.h> #FUSES XT,NOWDT #use delay(clock=4000000) #include <LCD1.c> // Incluimos el driver LCD1.c que contiene las //funciones de control del LCD. #BYTE TRISC = 0x87 // TRISC en 87h. #BYTE portC = 0x07 // PORTC en 07h. #BIT rc0 = 0x07.0 // RC0 en 0x07 patilla 0. void main() lcd_init(); // Inicializamos el LCD. while(1) lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la // posición 1 línea 1 . printf(lcd_putc,"HOLA MUNDO"); // Escribimos todo eso // en formato entero hexadecimal //mayusculas. delay_ms(1000); // Retardo de 1 segundo. Con este programa hacemos que el mensaje “HOLA MUNDO” salga representado en el LCD en la línea 1 posición 1. El microcontrolador envía cada letra al LCD en código ASCII y el LCD representa todas ellas formando el mensaje.

30



5.5.- Programa de prueba de sensores.

//**************************** SENSORES ***************************** #include <16F876A.h> #FUSES XT,NOWDT #use delay(clock=4000000) #include <LCD1.c> // Incluimos el driver LCD1.c que contiene las //funciones de control del LCD.

31



#BYTE TRISA = 0x85 // TRISC en 85h. #BYTE portA = 0x05 // PORTC 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 RA4 = 0x05.4 // RA4 en 0x05 patilla 4. #BIT RB3 = 0x06.3 // RB3 en 0x06 patilla 3. #BIT RC0 = 0x07.0 // RC0 en 0x07 patilla 0. #BIT VSENSA = 0x07.1 // VSENSA en 0x07 patilla 1. #BIT VSENSB = 0x07.2 // VSENSB en 0x07 patilla 2. #BIT RC3 = 0x07.3 // RC3 en 0x07 patilla 3. #BIT RC5 = 0x07.5 // RC5 en 0x07 patilla 5. #BIT RC6 = 0x07.6 // RC6 en 0x07 patilla 6. #BIT TB3 = 0x86.3 #BIT RA0 = 0X05.0 #BIT RA1 = 0X05.1 #BIT RA2 = 0X05.2 #BIT RA3 = 0X05.3 #BIT RA5 = 0X05.5 void main() TRISC = 0B00000000; // Defines Puerto C como SALIDA de datos. TRISA = 0B00101111; // Defines las patillas del Puerto A. RC0 = 0; RC3 = 0; VSENSA = 1; VSENSB = 1; lcd_init(); // Inicializamos el LCD. while(1) lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"%u"RA5); // Escribimos RA5 como el bit más //significativo. lcd_gotoxy(2,1); // Posicionamos el Cursor del LCD en la

32



//posición 2 línea 1 . printf(lcd_putc,"%u"RA3); // Escribimos RA3 como el cuarto bit //menos significativo. lcd_gotoxy(3,1); // Posicionamos el Cursor del LCD en la //posición 3 línea 1 . printf(lcd_putc,"%u"RA2); // Escribimos RA2 como el tercer bit //menos significativo. lcd_gotoxy(4,1); // Posicionamos el Cursor del LCD en la //posición 4 línea 1 . printf(lcd_putc,"%u"RA1); // Escribimos RA1 como el segundo bit //menos significativo. lcd_gotoxy(5,1); // Posicionamos el Cursor del LCD en la //posición 5 línea 1 . printf(lcd_putc,"%u"RA0); // Escribimos RA0 como el bit menos //significativo. Con este programa conseguimos ver en el LCD la información a nivel de bits que el microcontrolador tiene en cada momento de los sensores, siendo el sensor derecho el bit más significativo

33



5.6.- Programa rastreador.

34



35



36



37



38



//*************************** Rastreador ****************************** #include <16F876A.h> #FUSES XT,NOWDT #use delay(clock=4000000) #include <LCD1.c> // Incluimos el driver LCD1.c que contiene las //funciones de control del LCD. #BYTE TRISA = 0x85 // TRISC en 85h. #BYTE portA = 0x05 // PORTC 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 MOI1 = 0x05.4 // RA4 en 0x05 patilla 4. #BIT MOI2 = 0x07.5 // RC5 en 0x07 patilla 5. #BIT MOD1 = 0x07.0 // RC0 en 0x07 patilla 0. #BIT MOD2 = 0x07.3 // RC3 en 0x07 patilla 3. #BIT VSENSA = 0x07.1 // VSENSA en 0x07 patilla 1. #BIT VSENSB = 0x07.2 // VSENSB en 0x07 patilla 2. #BIT RC6 = 0x07.6 // RC6 en 0x07 patilla 6. #BIT TB3 = 0x86.3 #BIT SEN1 = 0X05.0 #BIT SEN2 = 0X05.1 #BIT SEN3 = 0X05.2 #BIT SEN4 = 0X05.3 #BIT SEN5 = 0X05.5 int n; int16 fin; // ******************** Declaración de funciones *********************** void ZonaDerecha(void); void ZonaDerechaTemp(void); void ZonaIzquierda(void); void ZonaIzquierdaTemp(void);

39



// ******************* Rastreando la Zona Derecha ********************* void ZonaDerecha(void) lcd_gotoxy(1,2); // Posicionamos el Cursor del LCD en la //posición 1 línea 2 . printf(lcd_putc,"Zona Derecha "); // Escribimos La zona por la que los //sensores están leyendo. if( SEN3 == 0 && SEN4 == 1) MOD1 = 1; MOD2 = 0; MOI1 = 0; MOI2 = 1; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"ADELANTE "); // Escribimos RA5 como el bit mas //significativo. if( SEN3 == 0 && SEN4 == 0) MOD1 = 0; MOD2 = 1; MOI1 = 0; MOI2 = 1; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"DERECHA "); // Escribimos RA5 como el bit mas //significativo. if( SEN3 == 1 && SEN4 == 1) MOD1 = 1; MOD2 = 0; MOI1 = 1; MOI2 = 0; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"IZQUIERDA "); // Escribimos RA5 como el bit mas //significativo. if( SEN3 == 1 && SEN4 == 0) MOD1 = 0; MOD2 = 1; MOI1 = 0; MOI2 = 1; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 .

40



printf(lcd_putc,"Buscando...der"); // Escribimos RA5 como el bit mas //significativo. //***************** Bifurcación por la Zona derecha ******************** void ZonaDerechaTemp(void) lcd_gotoxy(1,2); // Posicionamos el Cursor del LCD en la //posición 1 línea 2 . printf(lcd_putc,"Zona Derecha "); // Escribimos La zona por la que los //sensores están leyendo. n=0; while(n != fin) if( SEN3 == 0 && SEN4 == 1) MOD1 = 1; MOD2 = 0; MOI1 = 0; MOI2 = 1; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"ADELANTE "); // Escribimos RA5 como el bit //mas significativo. if( SEN3 == 0 && SEN4 == 0) MOD1 = 0; MOD2 = 1; MOI1 = 0; MOI2 = 1; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"DERECHA "); // Escribimos RA5 como el bit mas //significativo. if( SEN3 == 1 && SEN4 == 1) MOD1 = 1; MOD2 = 0; MOI1 = 1; MOI2 = 0; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"IZQUIERDA "); // Escribimos RA5 como el bit mas //significativo. if( SEN3 == 1 && SEN4 == 0)

41



MOD1 = 0; MOD2 = 1; MOI1 = 0; MOI2 = 1; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"Buscando...der"); // Escribimos RA5 como el bit mas //significativo. n = n + 1; delay_ms(10); // ******************* Reasteando la Zona Izquierda ******************** void ZonaIzquierda(void) lcd_gotoxy(1,2); // Posicionamos el Cursor del LCD en la //posición 1 línea 2 . printf(lcd_putc,"Zona Izquierda"); // Escribimos La zona por la que los //sensores están leyendo. if( SEN2 == 1 && SEN3 == 0) MOD1 = 1; MOD2 = 0; MOI1 = 0; MOI2 = 1; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"ADELANTE "); // Escribimos RA5 como el bit mas //significativo. if( SEN2 == 0 && SEN3 == 0) MOD1 = 1; MOD2 = 0; MOI1 = 1; MOI2 = 0; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"IZQUIERDA "); // Escribimos RA5 como el bit mas //significativo. if( SEN2 == 1 && SEN3 == 1) MOD1 = 0; MOD2 = 1; MOI1 = 0; MOI2 = 1;

42



lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"DERECHA "); // Escribimos RA5 como el bit mas //significativo. if( SEN2 == 0 && SEN3 == 1) MOD1 = 1; MOD2 = 0; MOI1 = 1; MOI2 = 0; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"Buscando...izq"); // Escribimos RA5 como el bit mas //significativo. //****************** Bifurcación por la Zona Izquierda******************* void ZonaIzquierdaTemp(void) lcd_gotoxy(1,2); // Posicionamos el Cursor del LCD en la //posición 1 línea 2 . printf(lcd_putc,"Zona Izquierda"); // Escribimos La zona por la que //los sensores están leyendo. n=0; while(n != fin) if( SEN2 == 1 && SEN3 == 0) MOD1 = 1; MOD2 = 0; MOI1 = 0; MOI2 = 1; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"ADELANTE "); // Escribimos RA5 como el bit mas //significativo. if( SEN2 == 0 && SEN3 == 0) MOD1 = 1; MOD2 = 0; MOI1 = 1; MOI2 = 0; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"IZQUIERDA "); // Escribimos RA5 como el bit mas //significativo.

43



if( SEN2 == 1 && SEN3 == 1) MOD1 = 0; MOD2 = 1; MOI1 = 0; MOI2 = 1; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"DERECHA "); // Escribimos RA5 como el bit mas //significativo. if( SEN2 == 0 && SEN3 == 1) MOD1 = 1; MOD2 = 0; MOI1 = 1; MOI2 = 0; lcd_gotoxy(1,1); // Posicionamos el Cursor del LCD en la //posición 1 línea 1 . printf(lcd_putc,"Buscando...izq"); // Escribimos RA5 como el bit mas //significativo. n = n + 1; delay_ms(10); //************************* Programa Principal************************* void main() TRISC = 0B00000000; // Defines Puerto C como SALIDA de //datos. TRISA = 0B00101111; // Defines las patillas del Puerto A. MOD1 = 0; MOD2 = 0; VSENSA = 1; VSENSB = 1; lcd_init(); // Inicializamos el LCD. fin = 60; while(1) ZonaDerecha(); if (SEN5 == 0)

44



ZonaDerechaTemp(); if (SEN1 == 0) ZonaIzquierdaTemp(); do ZonaIzquierda(); if (SEN1 == 0) ZonaIzquierdaTemp(); while(SEN5 != 0); ZonaDerecha(); SEN1, SEN2, SEN3, SEN4 y SEN5 es la información que le llega al microcontrolador de cada sensor, donde mirando desde la trasera del robot, SEN1 es el sensor más a la izquierda después SEN2, hasta SEN5 que esta en el extremo derecho. MOD1 y MOD2 se les ha llamado a las patillas de control del motor derecho. MIZ1 y MIZ2 son las patillas de control del motor izquierdo. La variable fin se ha puesto para precisar el tiempo de las zonas temporizadas. A los sensores siempre se les está preguntando en el programa para saber en que situación se encuentra en cada momento. De 5 sensores dos son los que leen por la línea del recorrido, o bien SEN3 y SEN4 por la zona derecha de la línea, o bien SEN2 y SEN3 por la zona izquierda. El cambio de zona de lectura se produce cuando los sensores de los extremos detectan marca. Si SEN1 detecta marca se cambia a zona izquierda de lectura pero si ha sido SEN5 el que detecta marca se cambia a zona derecha de lectura. Para no salirse de la línea se ha diseñado un algoritmo lógico, los motores hacen girar el robot hacia el lado contrario por el que se salió, intentando en todo momento que SEN3 esté sobre la línea.

6.- Diseño de Placas de Circuitos Impresos. 6.1.- Placa de Alimentación. Bottom Copper

Top Copper

46



6.2.- Placa de Sensores. Bottom Copper

Top Copper

47



6.3.- Placa de Potencia. Bottom Copper

Top Copper

48



6.4.- Placa de Control. Bottom Copper

Top Copper

49



7.- Diseño mecánico.

50



8.- Lista componentes y precios.

Factura de materiales para el rastreador Gertrudis

Título del robot : Rastreador Gertrudis

Autor : Sergio Alonso Torija

Revisión :

Fecha de inicio : martes, 07 de octubre de 2008

Fecha de finalización : domingo, 15 de marzo de 2009

Total componentes : 108

28 Resistencias

Cantidad: Referencias Valor Coste unitario Coste

12

R1, R3, R5, R7, R9, R11, R13, R17, R19, R21, R23, R25

220

0.05 = 0.6

7

R2, R4, R6, R8, R10, R12, R26

10k

0.05 = 0.35

2 R14, R15 4k7 0.05 = 0.1

5

R16, R18, R20, R22, R24

18k

0.05 = 0.25

1 R27 100 0.05

1 R38 240 0.05

15 Condensadores

Cantidad: Referencias Valor Coste unitario

1 C1 2200uF 0.50

6

C2, C4, C9-C11, C14

100nF

0.05 = 0.3 =

1 C3 220uF 0.20

4 C5-C8 1uF 0.01 = 0.4

2 C13, C16 15pF 0.05 = 0.10

1 C15 10uF 0.05

11 Circuitos integrados

51




1 U1 LM350K_JOAN 1

1 U2 MAX232_JOAN 1.5

6

U3-U8

OPTOCOUPLER-NPN

0.35 = 21

1 U9 L298 3.5

1 U10 PIC16F876_JOAN 4.5

1 U11 74HC14 0.5

4 Transistores


4 Q1-Q4 BD139_JOAN 0.35 = 1.4

12 Diodos


11 D1, D2, D4-D12 1N4007_JOAN 0.2 = 2.2

1

D3

LED-BLUE_JOAN 0.15

38 Misceláneos


5 ANTENA, J14, J15, BORNIER 0.15 = 0.75

52



MASA3, MASA4 1_JOAN

1 BATERIA 9V 0.3

1

INICIO

CONMUTADOR JOAN

0.4

6

J1, J1A, J3, J3A, J5, J5A

CONN-SIL10_JOAN

0.4 = 2.4

4 J6-J9 CONN-SIL4 0.15 = 0.6

3

J10, JUMPER1, JUMPER2

CONN_SIL3_JOAN

0.15 = 0.45

1 J11 CONN-D9M 0.3

4

JP, JP1, JP2, JP21

BORNIER 2_JOAN

0.3 = 1.2

1 LCD1 LCD-16 X 2_JOAN 7

2

MDE, MIZ

MOTOR-DC_JOAN

10 = 20

1

ON-OFF

INTERRUPTOR_JOAN

1

5 OP1-OP5 CNY70_JOAN 0.35 = 1.75

1

RESET

PULSADOR_JOAN

0.4

1

RF1

CEBEK-C-0504_JOAN

7

1 RV1 5k 0.3

1 X1 CRYSTAL_JOAN 1

57.65

Documents

Memoria Rastreador - pedrojoanmiro.webcindario.com · Esquema eléctrico de simulación con Proteus ... suavizan el arranque y paro de motores. ... El integrado L298 es un inversor