proyecto: robot hexápodo (spidy.00) Departamento de Electricidad-Electrónica Alumnos: Rodrigo García Martín Jesús Torrejón López Instituto: I.E.S. Joan Miró Localidad: San Sebastián de los Reyes Curso: 2008/2009
Índice: Página. Descripción del proyecto.. 3 2. Diagrama de bloques... 5 3. Análisis de los bloques... 6 3.. Control+LCD... 6 3.2. Control PWM servos SD20 + Servo 7 3.3. Alimentación... 8 3.4. Comunicación µc-pc... 9 3.5. Receptor radiofrecuencia..0 3.6. Mando emisor radiofrecuencia.0 4. Esquemas eléctricos.. 2 4.. Bloque control.2 4.2. Alimentación/Comunicación µc-pc...3 5. Diseño de circuitos impresos.4 5.. Bloque control.4 5.2. Alimentación/Comunicación µc-pc..6 6. Diseño mecánico.8 7. Programación 9 7.. Pruebas.9 7... LCD 9 7..2 SD20+servos..20 7.2. Programas.38 7.2.. Inicialización...38 7.2.2. Andar hacia delante...48 8. Lista de componentes 56 8.. Bloque control.56 8.2. Alimentación / Comunicación µc-pc...57 8.3. Estructura.58 9. Coste económico..59 0. Referencias..60. Anexos.6.. Características principales del PIC 6F876A 6.2. Características principales SD20.6 2
. Descripción del proyecto El proyecto consiste en diseñar y fabricar un robot hexápodo. El robot está formado por seis patas, con tres servo-motores por pata para así darle al robot tres grados de libertad por cada pata, siendo estos hombro, codo y mano. El primer grado de libertad estaría formado por el primer servo de las patas, este realizaría la función de hombro realizando movimiento de derecha a izquierda. El segundo grado de libertad sería el segundo servo de las patas; este realizaría la función de codo con movimientos de arriba abajo. El tercer servo de las patas seria la mano, también realizando movimientos de arriba abajo. El robot consta de dos placas de circuito impreso; una de alimentación más conexión con el PC y otra de control; tanto de servos como de las distintas funciones. El robot es controlado por un PIC6F876A y por un chip SD20. El primero de estos será el que controle la parte del LCD y el modo radiocontrol, mientras que el segundo será el encargado de controlar los servo-motores de las patas mediante una señal PWM. Se le ha dotado de una pantalla LCD para que nos indique lo que está ocurriendo en su entorno en todo momento. Actualmente, el robot no dispone de ningún tipo de sensores de obstáculos, pero próximamente contara con ellos. La función de radiocontrol se realizará mediante 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 de los circuitos impresos se realiza con una herramienta denominada Proteus, la cual, 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. 3
La programación del robot se ha realizado mediante lenguaje c con el programa Pic C Compiler. El software se puede grabar 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. 4
2. Diagrama de bloques RECEPTOR RF LCD HACIA TODAS LAS PLACAS ALIMENTACIÓN 5V PORT B RC7 CONTROL RC6 RC7 COMUNICACIÓN µc-pc I2C CONTROL SERVOS MANDO RF S..S8 SERVOS 5
3. Análisis de los bloques 3.. Control + LCD x0 Un microcontrolador PIC6F876A es el encargado de realizar el control del robot: gestión del LCD, comunicación serie, controlador por I2C de otros dispositivos y de la comunicación por RF. Su frecuencia de trabajo es de 4Mhz, ejecutando una instrucción cada µs. Está dotado con un pulsador de inicio, un jumper (j 2) para seleccionar el modo en el que queremos que trabaje nuestro robot y un último jumper para utilizar la comunicación serie según nos interese, si es para introducirle un nuevo código o bien para ejecutarlo en modo radiofrecuencia. La función del LCD es básicamente, mostrar información sobre el programa que está ejecutando en ese momento o cualquier otro tipo de mensaje que se desee presentar en la pantalla. 6
3.2. Control PWM servos SD20+ Servo Este bloque gira en torno a ese chip central. Es un PIC 6F872 preprogramado. Con la característica de que es capaz de generar 20 señales PWM independientes. Mediante comunicación I2C, le daremos instrucciones desde el PIC de control que el interpretará y según estas generará una señal PWM en una salida elegida previamente por el usuario. Tiene la particularidad de que necesita un cristal de 8 MHz con toma de tierra intermedia. Para generar la señal PWM hemos codificado el rango de actuación de un servo, que es 80 de libertad, en 256 códigos, por lo que cada variación de una unidad en código equivale a 0,70. Se han incluido 6 señales digitales para, en un futuro, sensar el apoyo de las patas. Un servo es un dispositivo similar a un motor de corriente continua, que tiene la capacidad de ubicarse en cualquier posición dentro de su rango de operación, y mantenerse estable en dicha posición. Está conformado por un motor, una caja reductora y un circuito de control. 7
2 2 3 4 5 6 7 8 9 0 V2 VDD3 RC6 RC7(BL) V2 2 2 K A A K I.E.S. Joan Miró (S.S. de los Reyes) / Dpto. Electrónica 3.3. Alimentación D2 K A ON-OFF 2 A D K 2 U VIN VOUT 3 VDD3 BATERIA C C2 00nF 3 ADJ RV k D4 R D3 R38 C5 C3 C4 MASA3 JP JA Está situada en la primera placa. Aunque no es el esquema final, pero actualmente nos está sirviendo para realizar las pruebas necesarias del robot. La Fuente de Alimentación es un circuito que se encargar de obtener una tensión de 5V (VDD3) continua a partir de una superior de 2V. Para ello se ha utilizado el regulador LM 350K (Encapsulado TO3) que nos puede dar una corriente de salida Imax de 3 A. La parte de filtrado de de señales esta formador por los condensadores C, C2, C3 y C4. Los condensadores C y C3 son condensadores de filtrado de la señal alterna. Se encargar de filtrar la señal alterna para que se quede una señal continua limpia para poder trabajar sin problemas. Los condensadores C2 y C4 se encargan de filtrar las señales externas que el circuito pueda absorber y las lleva a masa. Esto se debe a que las pistas del circuito, actúan de antena y estos condensadores filtran esas señales. La parte de regulación de tensión, esta formada por el potenciómetro RV, la resistencia R38 y el condensador C5. El potenciómetro RV nos variara la tensión de salida según la posición en la que lo pongamos, para que esto no se produzca de manera brusca, sino que varié lentamente necesitamos el condensador C5. La resistencia R38 nos proporciona una corriente fija para el potenciómetro RV y el condensador C5. Las funciones de los diodos D, D2, D3 y D4, son las siguientes. 8
VCC VDD3 I.E.S. Joan Miró (S.S. de los Reyes) / Dpto. Electrónica El diodo D, es un diodo de protección del circuito. Este protege de manera que si se enchufase la batería del revés, este evitaría que se estropease los componentes de circuito. El diodo D2, sirve para proteger el regulador de tensión LM350K, evitando que las tensiones entren en el regulador por la salida de este, de manera que estas tensiones se desviarían por el diodo hasta la entrada del regulador. El diodo D3 nos indica el funcionamiento de nuestra fuente. Cuando este se ilumine significa que la fuente de alimentación estará funcionando. Pero para que este diodo no se rompa, tenemos una resistencia limitadora de corriente, R que evita una corriente elevada. El diodo D4 es otro protector del regulador LM350K. La idea general era el diseño de una placa común entre el resto de alumnos, por lo que este diodo protege so por error a la hora del cambio de placas, hemos conectado la batería a la salida de 5 voltios, el polo positivo a la masa y el polo negativo a la salida de 5 voltios. El pin Masa3 es otro punto de masa. El conector J6 se encarga de llevar a la otra placa una salida fija de 2 V, JP lleva una tensión fija de 5V y JA se encarga de de alimentar también uno de los micros de la otra placa. 3.4. Comunicación µc-pc C5 J 5 9 4 8 3 7 2 6 TXPC RXPC 4 3 7 8 2 6 TOUT RIN T2OUT R2IN 3 C- VS+ VS- 6 U2 VCC C+ TIN 2 ROUT 0 T2IN 9 R2OUT RC6 RC7(BL) C9 C6 C7 C2-5 GND 5 C2+ 4 C8 El cargador del programa desde el PC al micro del robot consiste en un circuito que intercambia niveles TTL a RS 232 y viceversa donde un 0 lógico en TTL equivale a 0V en RS232 equivale a una tensión comprendida entre +3 y +5V. Un lógico en TTL equivale a +5V y en RS232 equivale a una tensión comprendida entre -3 y -5V. El Circuito Integrado MAX 232 se encarga de convertir los niveles de TTL a RS232. 9
2 2 2 2 2 K K K K K A A A A A K 5 3 4 3 2 VSS A Vcc GND3 Antena GND2 - Ve 2 2 GND GND 2 3 7 3 4 5 Vcc GND Antena GND2 GND3 TEST Vs Vcc I.E.S. Joan Miró (S.S. de los Reyes) / Dpto. Electrónica 3.5. Receptor radiofrecuencia RF2 CEBEK-C-0504_JOAN Receptor de Datos CEBEK C-0504 VCC(5V) RC7(RF) ANTENA 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.6. Mando emisor radiofrecuencia Mando VDD D6E SW6E 2 A K INTERRUPTOR_JOAN N4007_JOAN BATE 9V U2E 7805_JOAN VI CE 220uF VO 3 C2E 220uF R6E 220 QE BD36_JOAN R7E 2.2k E_RFE Emisor de Datos CEBEK C-0503 D7E LED-RED_JOAN CONE BORNIER_JOAN C3E 5pF RE 220 DE LED-YELLOW_JOAN R2E 220 D2E LED-GREEN_JOAN R3E 220 D3E LED-RED_JOAN R4E 220 D4E LED-RED_JOAN R5E 220 D5E LED-RED_JOAN RBE RB3E RB0E RB2E RB4E RB0E RBE RB2E RB3E RB4E UE 2 RB0/INT OSC/CLKIN 22 RB OSC2/CLKOUT 23 RB2 MCLR/Vpp/THV 24 RB3/PGM 25 RB4 RA0/AN0 26 RB5 RA/AN 27 RB6/PGC RA2/AN2/VREF- 28 RB7/PGD RA3/AN3/VREF+ RA4/T0CKI RC0/TOSO/TCKI RA5/AN4/SS 2 RC/TOSI/CCP2 3 RC2/CCP 4 RC3/SCK/SCL 5 RC4/SDI/SDA 6 RC5/SDO 7 RC6/TX/CK 8 RC7/RX/DT 9 0 2 3 4 5 6 7 VDD XE 4MHz C4E 5pF SWE SW2E SW3E SW4E SW5E PIC6F876_JOAN Izquierda Atras Adelante Parar Derecha 0
El mando tiene la misión de transmitir un código asociado a cada pulsador, para poder controlar el robot. El microcontrolador PIC 6F876a lee los pulsadores y transmite los códigos vía serie a la tarjeta transmisora de radiofrecuencia a una velocidad de 562,5 baudios por segundo. Es una transmisión asíncrona (bit de comienzo, 8bit de Datos, bit de parada sin bit de paridad). La Alimentación procede de un regulador 7805 que suministra 5V a todos los circuitos. El TRT QE 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 6F876a trabaja a una frecuencia de 4 MHz y ejecuta una instrucción en us. 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 C y C2 son filtros.
4. Esquemas eléctricos 4.. Bloque control 2
2 2 2 3 4 5 6 7 8 9 0 V2 GND3 VDD3 GND3 GND3 V2 GND3 GND3 GND3 GND3 GND3 VDD3 RC6 RC7(BL) GND3 GND3 GND3 GND3 2 2 K A A K VCC VDD3 I.E.S. Joan Miró (S.S. de los Reyes) / Dpto. Electrónica 4.2. Alimentación / Comunicación µc-pc C5 J 5 9 4 8 3 7 2 6 TXPC RXPC 4 3 7 8 2 6 3 C- TOUT RIN T2OUT R2IN VS+ VS- 6 VCC C+ TIN ROUT T2IN R2OUT U2 2 0 9 RC6 RC7(BL) C9 C6 C7 C2-5 GND 5 C2+ 4 C8 D2 K A N4007_JOAN ON-OFF 2 A D K 2 U LM350K_JOAN VIN VOUT 3 VDD3 BATERIA 7.2V C 2200uF C2 00nF 3 ADJ RV k R 0k D4 240 N4007_JOAN D3 R38 C5 uf C3 2200uF C4 00nF J6 JP J BORNIER BORNIER 2_JOAN 2_JOAN JA CONN-SIL0_RODRIGO 3
5. Diseño de circuitos impresos 5.. Bloque control Cara de componentes y Top Copper 4
Bottom Copper 5
5.2. Alimentación / Comunicación µc-pc Cara de componentes y Top Copper 6
Bottom Copper 7
6. Diseño mecánico Teniendo en cuenta que el robot es un hexápodo se decidió que el cuerpo tuviese forma de hexágono regular. Son dos planchas de unos 30cm en la diagonal que se colocan a modo de sándwich, liberando un espacio intermedio para baterías y servos. El diseño de las patas ha sido continuo y evolutivo, y en la actualidad no disponemos de los diseños del último modelo, tanto del brazo como de la mano. M M Brazo M Mano Codo Hombro Mano 8
7. Programación 7.. Pruebas 7... LCD º PRUEBA DEL LCD /* ************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. #include <LCD.c> // Incluimos el driver LCD.c que contiene las funciones de control del LCD. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); /* ****************************************************** Función principal o programa principal ************************************************ */ void main() { Sd20_ini(); lcd_init(); // Inicializamos el LCD. { lcd_gotoxy(,); printf(lcd_putc,"i.e.s JOAN MIRO"); lcd_gotoxy(,); printf(lcd_putc,"robot SPYDI"); 9
7..2. SD20 + servos º PRUEBA DEL SD20 /* ************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. #include <LCD.c> // Incluimos el driver LCD.c que contiene las funciones de control del LCD. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); /* ****************************************************** Función principal o programa principal ************************************************ */ void main() { Sd20_ini(); While(){ // Pata : // Hombro. Sd20(6,00); // Posicionamos el Servo del SD20 en 200. delay_ms(50); // Codo. Sd20(7,80); // Posicionamos el Servo2 del SD20 en 200. delay_ms(50); // Mano. Sd20(8,20); // Posicionamos el Servo3 del SD20 en 200. delay_ms(00); 20
Sd20(6,50); // Posicionamos el Servo del SD20 en 50. delay_ms(50); Sd20(7,40); // Posicionamos el Servo2 del SD20 en 50. delay_ms(00); Sd20(8,90); // Posicionamos el Servo3 del SD20 en 00. delay_ms(50); /* ******************* Función Sd20_ini ******************************* */ void Sd20_ini (void) { // Fijamos el rango de trabajo de los servor desde THmin= 0,480 ms hasta THmax= 2,520 ms. // THmin = Reg22,Reg23 + 20uS // THmax =(256x255)/Reg2 +(Reg22,Reg23+20)= // THmin = Reg22,Reg23 +20 us = 460uS + 20uS = 480 us ( 460d --> CCH ) // THmax =(256x255)/32 +(460+20)= 2520 us i2c_write(0xc2); i2c_write(2); expandido. i2c_write(32); // Seleccionamos el SD20 // Registro de configuración extandar o control modo i2c_write(0xc2); // Seleccionamos el SD20 i2c_write(22); // Dirección 22H del SD20 Modo expansor de offset(parte Alta) i2c_write(0x); // 460D -->0CCH (Se introduce la parte alta 0H) i2c_write(0xc2); // Seleccionamos el SD20 i2c_write(23); // Dirección 23H del SD20 Modo expansor de offset(parte Baja) i2c_write(0xcc); // 460D -->0CCH (Se introduce la parte baja CCH) /* ********************** Función Sd20(int8,int8) ************************** */ void Sd20(int8 servo, int8 posicion) { 2
i2c_write(0xc2); i2c_write(servo); i2c_write(posicion); // Seleccionamos el SD20 // Seleccionamos el Servo // Posicionamos el Servo en el extremo A 2º prueba del SD20 /* ************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); /* ****************************************************** Función principal o programa principal ************************************************ */ void main() { Sd20_ini(); While() // centrado de los servos { // centrado uña Sd20(,27); // Posicionamos el Servo del SD20 en 00. Sd20(2,27); // Posicionamos el Servo del SD20 en 50. 22
Sd20(3,27); // Posicionamos el Servo del SD20 en 50. while(); /* ******************************************************** Función Sd20_ini **************************************************************** */ void Sd20_ini (void) { // Fijamos el rango de trabajo de los servor desde THmin= 0,480 ms hasta THmax= 2,520 ms. // THmin = Reg22,Reg23 + 20uS // THmax =(256x255)/Reg2 +(Reg22,Reg23+20)= // THmin = Reg22,Reg23 +20 us = 460uS + 20uS = 480 us ( 460d --> CCH ) // THmax =(256x255)/32 +(460+20)= 2520 us i2c_write(0xc2); i2c_write(2); expandido. i2c_write(32); // Seleccionamos el SD20 // Registro de configuración extandar o control modo i2c_write(0xc2); // Seleccionamos el SD20 i2c_write(22); // Dirección 22H del SD20 Modo expansor de offset(parte Alta) i2c_write(0x); // 460D -->0CCH (Se introduce la parte alta 0H) i2c_write(0xc2); i2c_write(23); Baja) i2c_write(0xcc); // Seleccionamos el SD20 // Dirección 23H del SD20 Modo expansor de offset(parte // 460D -->0CCH (Se introduce la parte baja CCH) 23
/* ************************************************** Función Sd20(int8,int8) **************************************************************** */ void Sd20(int8 servo, int8 posicion) { i2c_write(0xc2); i2c_write(servo); i2c_write(posicion); // Seleccionamos el SD20 // Seleccionamos el Servo // Posicionamos el Servo en el extremo A 3º PRUEBA DEL SD20 /* ************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. #include <LCD.c> // Incluimos el driver LCD.c que contiene las funciones de control del LCD. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); /* ****************************************************** Función principal o programa principal ************************************************ */ void main() { 24
Sd20_ini(); lcd_init(); // Inicializamos el LCD. { lcd_gotoxy(,); printf(lcd_putc,"i.e.s JOAN MIRO"); delay_ms(2500); lcd_gotoxy(,); printf(lcd_putc,"robot SPYDI"); delay_ms(2500); lcd_gotoxy(4,); printf(lcd_putc,"coco y"); lcd_gotoxy(4,2); printf(lcd_putc,"txus"); delay_ms(2500); Sd20_ini(); While() // Pata : // Hombro. Sd20(4,200); // Posicionamos el Servo del SD20 en 200. delay_ms(50); // Codo. Sd20(5,200); // Posicionamos el Servo2 del SD20 en 200. delay_ms(50); // Mano. Sd20(6,20); // Posicionamos el Servo3 del SD20 en 200. delay_ms(00); Sd20(4,50); // Posicionamos el Servo del SD20 en 50. delay_ms(50); Sd20(5,50); // Posicionamos el Servo2 del SD20 en 50. delay_ms(00); Sd20(6,90); // Posicionamos el Servo3 del SD20 en 00. delay_ms(50); /* ******************************************************** Función Sd20_ini **************************************************************** */ void Sd20_ini (void) 25
{ // Fijamos el rango de trabajo de los servor desde THmin= 0,480 ms hasta THmax= 2,520 ms. // THmin = Reg22,Reg23 + 20uS // THmax =(256x255)/Reg2 +(Reg22,Reg23+20)= // THmin = Reg22,Reg23 +20 us = 460uS + 20uS = 480 us ( 460d --> CCH ) // THmax =(256x255)/32 +(460+20)= 2520 us i2c_write(0xc2); i2c_write(2); expandido. i2c_write(32); // Seleccionamos el SD20 // Registro de configuración extandar o control modo i2c_write(0xc2); // Seleccionamos el SD20 i2c_write(22); // Dirección 22H del SD20 Modo expansor de offset(parte Alta) i2c_write(0x); // 460D -->0CCH (Se introduce la parte alta 0H) i2c_write(0xc2); i2c_write(23); Baja) i2c_write(0xcc); // Seleccionamos el SD20 // Dirección 23H del SD20 Modo expansor de offset(parte // 460D -->0CCH (Se introduce la parte baja CCH) /* ************************************************** Función Sd20(int8,int8) **************************************************************** */ void Sd20(int8 servo, int8 posicion) { i2c_write(0xc2); i2c_write(servo); i2c_write(posicion); // Seleccionamos el SD20 // Seleccionamos el Servo // Posicionamos el Servo en el extremo A 26
4º PRUEBA DEL SD20 /* ************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. #include <LCD.c> // Incluimos el driver LCD.c que contiene las funciones de control del LCD. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); /* ****************************************************** Función principal o programa principal ************************************************ */ void main() { Sd20_ini(); lcd_init(); While() // Inicializamos el LCD. { lcd_gotoxy(,); printf(lcd_putc,"i.e.s JOAN MIRO"); //delay_ms(2500); lcd_gotoxy(,2); printf(lcd_putc,"robot SPYDI"); // delay_ms(2500); 27
// centrado codo Sd20(2,27); // Posicionamos el Servo del SD20 en 00. Sd20(5,27); // Posicionamos el Servo del SD20 en 50. Sd20(8,27); // Posicionamos el Servo del SD20 en 50. Sd20(,27); // Posicionamos el Servo del SD20 en 00. Sd20(4,27); // Posicionamos el Servo del SD20 en 50. Sd20(7,27); // Posicionamos el Servo del SD20 en 50. // centrado hombro Sd20(,27); // Posicionamos el Servo del SD20 en 00. Sd20(4,27); // Posicionamos el Servo del SD20 en 50. Sd20(7,27); // Posicionamos el Servo del SD20 en 50. Sd20(0,27); // Posicionamos el Servo del SD20 en 00. Sd20(3,27); // Posicionamos el Servo del SD20 en 50. Sd20(6,27); // Posicionamos el Servo del SD20 en 50. // centrado mano Sd20(3,27); // Posicionamos el Servo del SD20 en 00. Sd20(6,27); // Posicionamos el Servo del SD20 en 50. Sd20(9,27); // Posicionamos el Servo del SD20 en 50. Sd20(2,27); // Posicionamos el Servo del SD20 en 00. Sd20(5,27); // Posicionamos el Servo del SD20 en 50. Sd20(8,27); // Posicionamos el Servo del SD20 en 50. delay_ms(500); // LEVANTANDO Sd20(2,74); // Posicionamos el Servo del SD20 en 00. 28
Sd20(5,74); // Posicionamos el Servo del SD20 en 50. Sd20(8,74); // Posicionamos el Servo del SD20 en 50. Sd20(,80); // Posicionamos el Servo del SD20 en 00. Sd20(4,80); // Posicionamos el Servo del SD20 en 50. Sd20(7,80); // Posicionamos el Servo del SD20 en 50. while(); /* ******************************************************** Función Sd20_ini **************************************************************** */ void Sd20_ini (void) { // Fijamos el rango de trabajo de los servor desde THmin= 0,480 ms hasta THmax= 2,520 ms. // THmin = Reg22,Reg23 + 20uS // THmax =(256x255)/Reg2 +(Reg22,Reg23+20)= // THmin = Reg22,Reg23 +20 us = 460uS + 20uS = 480 us ( 460d --> CCH ) // THmax =(256x255)/32 +(460+20)= 2520 us i2c_write(0xc2); i2c_write(2); expandido. i2c_write(32); // Seleccionamos el SD20 // Registro de configuración extandar o control modo i2c_write(0xc2); // Seleccionamos el SD20 i2c_write(22); // Dirección 22H del SD20 Modo expansor de offset(parte Alta) i2c_write(0x); // 460D -->0CCH (Se introduce la parte alta 0H) i2c_write(0xc2); // Seleccionamos el SD20 29
i2c_write(23); Baja) i2c_write(0xcc); // Dirección 23H del SD20 Modo expansor de offset(parte // 460D -->0CCH (Se introduce la parte baja CCH) /* ************************************************** Función Sd20(int8,int8) **************************************************************** */ void Sd20(int8 servo, int8 posicion) { i2c_write(0xc2); i2c_write(servo); i2c_write(posicion); // Seleccionamos el SD20 // Seleccionamos el Servo // Posicionamos el Servo en el extremo A 5º PRUEBA DEL ROBOT (CENTRANDO TODOS LAS PATAS) /* ************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. #include <LCD.c> // Incluimos el driver LCD.c que contiene las funciones de control del LCD. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); 30
/* ****************************************************** Función principal o programa principal ************************************************ */ void main(){ int i,j; Sd20_ini(); lcd_init(); // Inicializamos el LCD. lcd_gotoxy(,); printf(lcd_putc,"i.e.s JOAN MIRO"); //delay_ms(2500); lcd_gotoxy(,2); printf(lcd_putc,"robot SPYDI"); // delay_ms(2500); //centrado hombro for(i=; i<8; i=i+3){ Sd20(i, 27); //centrado codo for(i=2; i<9; i=i+3){ Sd20(i, 27); //centrdo mano for(i=3; i<0; i=i+3){ Sd20(i, 96); for(i=2; i<20; i=i+3){ Sd20(i, 60); delay_ms(200); Sd20(, 27); Sd20(3, 74); Sd20(2, 74); 3
Sd20(7, 27); Sd20(9, 74); Sd20(8, 74); delay_ms(200); Sd20(, 80); Sd20(3, 74); Sd20(2, 74); Sd20(7, 74); Sd20(9, 74); Sd20(8, 74); delay_ms(200); Sd20(, 80); Sd20(3, 27); Sd20(2, 27); Sd20(7, 74); Sd20(9, 27); Sd20(8, 27); delay_ms(200); Sd20(0, 27); Sd20(2, 80); Sd20(, 80); Sd20(6, 27); Sd20(8, 80); Sd20(7, 80); delay_ms(200); Sd20(0, 80); Sd20(2, 80); Sd20(, 80); Sd20(6, 74); Sd20(8, 80); Sd20(7, 80); delay_ms(200); Sd20(0, 80); Sd20(2, 27); Sd20(, 27); 32
Sd20(6, 74); Sd20(8, 27); Sd20(7, 27); /* ******************************************************** Función Sd20_ini **************************************************************** */ void Sd20_ini (void) { // Fijamos el rango de trabajo de los servor desde THmin= 0,480 ms hasta THmax= 2,520 ms. // THmin = Reg22,Reg23 + 20uS // THmax =(256x255)/Reg2 +(Reg22,Reg23+20)= CCH ) // THmin = Reg22,Reg23 +20 us = 460uS + 20uS = 480 us ( 460d --> // THmax =(256x255)/32 +(460+20)= 2520 us i2c_write(0xc2); i2c_write(2); control modo expandido. i2c_write(32); i2c_write(0xc2); i2c_write(22); de offset(parte Alta) i2c_write(0x); alta 0H) i2c_write(0xc2); i2c_write(23); de offset(parte Baja) i2c_write(0xcc); baja CCH) // Seleccionamos el SD20 // Registro de configuración extandar o // Seleccionamos el SD20 // Dirección 22H del SD20 Modo expansor // 460D -->0CCH (Se introduce la parte // Seleccionamos el SD20 // Dirección 23H del SD20 Modo expansor // 460D -->0CCH (Se introduce la parte 33
/* ************************************************** Función Sd20(int8,int8) **************************************************************** */ void Sd20(int8 servo, int8 posicion) { i2c_write(0xc2); i2c_write(servo); i2c_write(posicion); // Seleccionamos el SD20 // Seleccionamos el Servo // Posicionamos el Servo en el extremo A PRUEBA DE RANGO DE MOVIMIENTOS MAXIMOS Y MINIMOS /* ************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. #include <LCD.c> // Incluimos el driver LCD.c que contiene las funciones de control del LCD. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); /* ****************************************************** Función principal o programa principal ************************************************ */ void main(){ int i; 34
Sd20_ini(); lcd_init(); // Inicializamos el LCD. lcd_gotoxy(,); printf(lcd_putc,"i.e.s JOAN MIRO"); //delay_ms(2500); lcd_gotoxy(,2); printf(lcd_putc,"robot SPYDI"); // delay_ms(2500); //centrado hombro for(i=; i<8; i=i+3){ Sd20(i, 27); //centrado codo for(i=2; i<9; i=i+3){ Sd20(i, 27); //centrdo mano for(i=3; i<20; i=i+3){ Sd20(i, 27); delay_ms(500); //maximo codo Sd20(2, 200); Sd20(7, 55); delay_ms(00); Sd20(3,65); Sd20(8,90); delay_ms(500); //minimo codo Sd20(2, 55); Sd20(7, 200); delay_ms(00); Sd20(3,27); Sd20(8, 27); 35
/* ******************************************************** Función Sd20_ini **************************************************************** */ void Sd20_ini (void) { // Fijamos el rango de trabajo de los servor desde THmin= 0,480 ms hasta THmax= 2,520 ms. // THmin = Reg22,Reg23 + 20uS // THmax =(256x255)/Reg2 +(Reg22,Reg23+20)= // THmin = Reg22,Reg23 +20 us = 460uS + 20uS = 480 us ( 460d --> CCH ) // THmax =(256x255)/32 +(460+20)= 2520 us i2c_write(0xc2); i2c_write(2); expandido. i2c_write(32); // Seleccionamos el SD20 // Registro de configuración extandar o control modo i2c_write(0xc2); // Seleccionamos el SD20 i2c_write(22); // Dirección 22H del SD20 Modo expansor de offset(parte Alta) i2c_write(0x); // 460D -->0CCH (Se introduce la parte alta 0H) i2c_write(0xc2); i2c_write(23); Baja) i2c_write(0xcc); // Seleccionamos el SD20 // Dirección 23H del SD20 Modo expansor de offset(parte // 460D -->0CCH (Se introduce la parte baja CCH) /* ************************************************** Función Sd20(int8,int8) **************************************************************** */ void Sd20(int8 servo, int8 posicion) 36
{ i2c_write(0xc2); i2c_write(servo); i2c_write(posicion); // Seleccionamos el SD20 // Seleccionamos el Servo // Posicionamos el Servo en el extremo A 37
7.2. Programas INICIO: LEVANTANDO EL ROBOT Y SALUDANDO /* ************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. #include <LCD.c> // Incluimos el driver LCD.c que contiene las funciones de control del LCD. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); /* ****************************************************** Función principal o programa principal ************************************************ */ void main(){ int i, j, k, l, aux; Sd20_ini(); lcd_init(); // Inicializamos el LCD. lcd_gotoxy(,); printf(lcd_putc,"i.e.s JOAN MIRO"); //delay_ms(2500); lcd_gotoxy(,2); printf(lcd_putc,"robot SPYDI"); // delay_ms(2500); //centrado hombro for(i=; i<8; i=i+3){ 38
Sd20(i, 27); //centrado codo for(i=2; i<0; i=i+3){ //DERECHA Sd20(i, 94); for(i=; i<9; i=i+3){ //IZQUIERDA Sd20(i, 60); //centrdo mano for(i=3; i<0; i=i+3){ //DERECHA Sd20(i, 94); for(i=2; i<20; i=i+3){ //IZQUIERDA Sd20(i, 60); delay_ms(5000); // codo for(aux=0; aux<30; aux++){ delay_ms(); j= 94+aux; k= 60-aux; for(i=2; i<0; i=i+3){ Sd20(i, j); //DERECHA Sd20((i+9), k); //IZQUIERDA delay_ms(500); // codo Sd20(2, 225); Sd20(5, 225); Sd20(8, 225); Sd20(, 30); Sd20(4, 30); Sd20(7, 30); delay_ms(0); 39
//mano Sd20(3,200); Sd20(6,200); Sd20(9,200); Sd20(2,55); Sd20(5,55); Sd20(8,55); delay_ms(500); //centrado hombro for(i=; i<8; i=i+3){ Sd20(i, 27); //centrado codo for(i=2; i<9; i=i+3){ Sd20(i, 27); //centrdo mano for(i=3; i<0; i=i+3){ Sd20(i, 96); for(i=2; i<20; i=i+3){ Sd20(i, 60); delay_ms(000); Sd20(5, 50); Sd20(4,04); delay_ms(200); Sd20(4, 50); Sd20(5,50); delay_ms(200); Sd20(6, 00); Sd20(7,50); while(){ Sd20(8, 80); 40
delay_ms(00); Sd20(8,60); delay_ms(00); /* ******************************************************** Función Sd20_ini **************************************************************** */ void Sd20_ini (void) { // Fijamos el rango de trabajo de los servor desde THmin= 0,480 ms hasta THmax= 2,520 ms. // THmin = Reg22,Reg23 + 20uS // THmax =(256x255)/Reg2 +(Reg22,Reg23+20)= // THmin = Reg22,Reg23 +20 us = 460uS + 20uS = 480 us ( 460d --> CCH ) // THmax =(256x255)/32 +(460+20)= 2520 us i2c_write(0xc2); i2c_write(2); expandido. i2c_write(32); // Seleccionamos el SD20 // Registro de configuración extandar o control modo i2c_write(0xc2); // Seleccionamos el SD20 i2c_write(22); // Dirección 22H del SD20 Modo expansor de offset(parte Alta) i2c_write(0x); // 460D -->0CCH (Se introduce la parte alta 0H) i2c_write(0xc2); i2c_write(23); Baja) i2c_write(0xcc); // Seleccionamos el SD20 // Dirección 23H del SD20 Modo expansor de offset(parte // 460D -->0CCH (Se introduce la parte baja CCH) 4
/* ************************************************** Función Sd20(int8,int8) **************************************************************** */ void Sd20(int8 servo, int8 posicion) { i2c_write(0xc2); i2c_write(servo); i2c_write(posicion); // Seleccionamos el SD20 // Seleccionamos el Servo // Posicionamos el Servo en el extremo A º INTENTO DE ANDAR /*************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. #include <LCD.c> // Incluimos el driver LCD.c que contiene las funciones de control del LCD. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); /* ****************************************************** Función principal o programa principal ************************************************ */ 42
void main(){ int i,j; Sd20_ini(); lcd_init(); // Inicializamos el LCD. lcd_gotoxy(,); printf(lcd_putc,"i.e.s JOAN MIRO"); //delay_ms(2500); lcd_gotoxy(,2); printf(lcd_putc,"robot SPYDI"); // delay_ms(2500); // centrado patas //centrado hombro for(i=; i<8; i=i+3){ Sd20(i, 27); //centrado codo for(i=2; i<0; i=i+3){ Sd20(i, 96); for(i=; i<20; i=i+3){ Sd20(i, 60); //centrdo mano for(i=3; i<0; i=i+3){ Sd20(i, 96); for(i=2; i<20; i=i+3){ Sd20(i, 60); // Preparacion de servos para andar delay_ms(200); //centrado º y 3º pata Sd20(, 27); Sd20(3, 74); Sd20(2, 74); Sd20(7, 27); Sd20(9, 74); Sd20(8, 74); 43
delay_ms(200); //centrado º y 3º pata Sd20(, 80); Sd20(3, 74); Sd20(2, 74); Sd20(7, 74); Sd20(9, 74); Sd20(8, 74); delay_ms(200); //centrado º y 3º pata Sd20(, 80); Sd20(3, 96); Sd20(2, 96); Sd20(7, 74); Sd20(9, 96); Sd20(8, 96); delay_ms(200); //centrado 4º y 6º pata Sd20(0, 27); Sd20(2, 80); Sd20(, 80); Sd20(6, 27); Sd20(8, 80); Sd20(7, 80); delay_ms(200); //centrado 4º y 6º pata Sd20(0, 80); Sd20(2, 80); Sd20(, 80); Sd20(6, 74); Sd20(8, 80); Sd20(7, 80); delay_ms(200); //centrado 4º y 6º pata Sd20(0, 80); Sd20(2, 60); Sd20(, 60); Sd20(6, 74); Sd20(8, 60); 44
Sd20(7, 60); delay_ms(600); while(){ // adelante patas,3,5 Sd20(, 27); Sd20(3, 74); Sd20(2, 74); delay_ms(00); Sd20(7, 29); Sd20(9, 74); Sd20(8, 74); delay_ms(00); Sd20(3, 80); Sd20(5, 80); Sd20(4, 80); delay_ms(200); Sd20(, 27); Sd20(3, 96); Sd20(2, 96); delay_ms(00); Sd20(7, 29); Sd20(9, 96); Sd20(8, 96); delay_ms(00); Sd20(3, 80); Sd20(5, 60); Sd20(4, 60); // adelante patas 2.4.6 delay_ms(200); Sd20(4, 74); Sd20(6, 74); Sd20(5, 74); delay_ms(00); Sd20(0, 33); Sd20(2, 80); Sd20(, 80); delay_ms(00); Sd20(6, 27); Sd20(8, 80); Sd20(7, 80); 45
delay_ms(200); Sd20(4, 74); Sd20(6, 96); Sd20(5, 96); delay_ms(00); Sd20(0, 33); Sd20(2, 60); Sd20(, 60); delay_ms(00); Sd20(6, 27); Sd20(8, 60); Sd20(7, 60); // reset inicial delay_ms(600); Sd20(, 80); Sd20(3, 96); Sd20(2, 96); Sd20(7, 74); Sd20(9, 96); Sd20(8, 96); Sd20(4, 27); Sd20(6, 96); Sd20(5, 96); Sd20(0, 80); Sd20(2, 60); Sd20(, 60); Sd20(6, 74); Sd20(8, 60); Sd20(7, 60); Sd20(3, 27); Sd20(5, 60); Sd20(4, 60); delay_ms(200); 46
/* ******************************************************** Función Sd20_ini **************************************************************** */ void Sd20_ini (void) { // Fijamos el rango de trabajo de los servor desde THmin= 0,480 ms hasta THmax= 2,520 ms. // THmin = Reg22,Reg23 + 20uS // THmax =(256x255)/Reg2 +(Reg22,Reg23+20)= // THmin = Reg22,Reg23 +20 us = 460uS + 20uS = 480 us ( 460d --> CCH ) // THmax =(256x255)/32 +(460+20)= 2520 us i2c_write(0xc2); i2c_write(2); expandido. i2c_write(32); // Seleccionamos el SD20 // Registro de configuración extandar o control modo i2c_write(0xc2); // Seleccionamos el SD20 i2c_write(22); // Dirección 22H del SD20 Modo expansor de offset(parte Alta) i2c_write(0x); // 460D -->0CCH (Se introduce la parte alta 0H) i2c_write(0xc2); i2c_write(23); Baja) i2c_write(0xcc); // Seleccionamos el SD20 // Dirección 23H del SD20 Modo expansor de offset(parte // 460D -->0CCH (Se introduce la parte baja CCH) /* ************************************************** Función Sd20(int8,int8) **************************************************************** */ void Sd20(int8 servo, int8 posicion) { 47
i2c_write(0xc2); i2c_write(servo); i2c_write(posicion); // Seleccionamos el SD20 // Seleccionamos el Servo // Posicionamos el Servo en el extremo A MOVIMIENTO DE ANDAR HACIA DELANTE /*************************************************** Control del SD20 ************************************************ */ #include <6F876A.h> #fuses XT,NOWDT,PUT,NOWRT #use delay(clock= 4000000) #use i2c(master, force_hw, slow, sda=pin_c4, scl=pin_c3) // Configuración de I2C // Definimos el PIC como maestro // Forzamos a trabajar con su hardware interno.(asociado a I2C) // Trabajamos a velocidad baja 00 Kbps // Elegimos sda=pin_c4 como patilla de datos. // Elegimos scl=pin_c3 como patilla de reloj. #include <LCD.c> // Incluimos el driver LCD.c que contiene las funciones de control del LCD. /* ****************************************************** Declaración de funcionesa ***************************************************************/ void Sd20_ini (void); void Sd20(int8,int8); /* ****************************************************** Función principal o programa principal ************************************************ */ void main(){ int i,j; Sd20_ini(); lcd_init(); // Inicializamos el Sd20. // Inicializamos el LCD. lcd_gotoxy(,); printf(lcd_putc,"i.e.s JOAN MIRO"); //delay_ms(2500); 48
lcd_gotoxy(,2); printf(lcd_putc,"robot SPYDI"); // delay_ms(2500); // centrado patas //centrado hombro for(i=; i<8; i=i+3){ Sd20(i, 27); //centrado codo for(i=2; i<0; i=i+3){ Sd20(i, 96); for(i=; i<20; i=i+3){ Sd20(i, 60); //centrdo mano for(i=3; i<0; i=i+3){ Sd20(i, 96); for(i=2; i<20; i=i+3){ Sd20(i, 60); // Preparacion de servos para andar delay_ms(200); while(){ // pata 6. // Realizara su movmiento habitual mientras el resto de patas realizaran un movmiento pararlelo delay_ms(00); Sd20(6, 27); Sd20(8, 80); Sd20(7, 80); Sd20(7, 94); 49
Sd20(9, 87); Sd20(8, 96); Sd20(0, 60); Sd20(2, 96); Sd20(, 60); Sd20(4, 29); Sd20(6, 96); Sd20(5, 96); Sd20(, 00); Sd20(3, 96); Sd20(2, 96); Sd20(3, 98); Sd20(5, 60); Sd20(4, 60); delay_ms(00); Sd20(6, 27); Sd20(8, 60); Sd20(7, 60); delay_ms(00); //pata 2 // Realizara su movmiento habitual mientras el resto de patas realizaran un movmiento pararlelo Sd20(4, 74); Sd20(6, 74); Sd20(5, 74); Sd20(6, 36); Sd20(8, 60); Sd20(7, 60); Sd20(7, 94); Sd20(9, 78); Sd20(8, 96); Sd20(0, 60); Sd20(2, 205); Sd20(, 60); Sd20(, 9); 50
Sd20(3, 96); Sd20(2, 96); Sd20(3, 07); Sd20(5, 60); Sd20(4, 60); delay_ms(00); Sd20(4, 74); Sd20(6, 96); Sd20(5, 96); delay_ms(00); //pata 4 // Realizara su movmiento habitual mientras el resto de patas realizaran un movmiento pararlelo Sd20(0, 60); Sd20(2, 80); Sd20(, 80); Sd20(6, 45); Sd20(8, 60); Sd20(7, 60); Sd20(7, 94); Sd20(9, 69); Sd20(8, 96); Sd20(, 82); Sd20(3, 96); Sd20(2, 96); Sd20(3, 6); Sd20(5, 60); Sd20(4, 60); delay_ms(00); Sd20(0, 60); Sd20(2, 60); Sd20(, 60); delay_ms(00); //pata 5
// Realizara su movmiento habitual mientras el resto de patas realizaran un movmiento pararlelo Sd20(, 27); Sd20(3, 74); Sd20(2, 74); Sd20(6, 54); Sd20(8, 60); Sd20(7, 60); Sd20(7, 94); Sd20(9, 60); Sd20(8, 96); Sd20(0, 60); Sd20(2, 69); Sd20(, 60); Sd20(4, 56); Sd20(6, 96); Sd20(5, 96); Sd20(3, 25); Sd20(5, 60); Sd20(4, 60); delay_ms(00); Sd20(, 27); Sd20(3, 96); Sd20(2, 96); delay_ms(00); //pata 5 // Realizara su movmiento habitual mientras el resto de patas realizaran un movmiento pararlelo Sd20(3, 80); Sd20(5, 80); Sd20(4, 80); Sd20(6, 63); Sd20(8, 60); Sd20(7, 60); Sd20(7, 94); Sd20(9, 5); 52
Sd20(8, 96); Sd20(0, 60); Sd20(2, 78); Sd20(, 60); Sd20(4, 47); Sd20(6, 96); Sd20(5, 96); Sd20(, 8); Sd20(3, 96); Sd20(2, 96); delay_ms(00); Sd20(3, 80); Sd20(5, 60); Sd20(4, 60); delay_ms(00); //pata 3 // Realizara su movmiento habitual mientras el resto de patas realizaran un movmiento pararlelo Sd20(7, 94); Sd20(9, 74); Sd20(8, 74); Sd20(6, 72); Sd20(8, 60); Sd20(7, 60); Sd20(0, 60); Sd20(2, 87); Sd20(, 60); Sd20(4, 38); Sd20(6, 96); Sd20(5, 96); Sd20(, 09); Sd20(3, 96); Sd20(2, 96); Sd20(3, 89); Sd20(5, 60); Sd20(4, 60); 53
delay_ms(00); Sd20(7, 94); Sd20(9, 96); Sd20(8, 96); /* ******************************************************** Función Sd20_ini **************************************************************** */ void Sd20_ini (void) { // Fijamos el rango de trabajo de los servor desde THmin= 0,480 ms hasta THmax= 2,520 ms. // THmin = Reg22,Reg23 + 20uS // THmax =(256x255)/Reg2 +(Reg22,Reg23+20)= // THmin = Reg22,Reg23 +20 us = 460uS + 20uS = 480 us ( 460d --> CCH ) // THmax =(256x255)/32 +(460+20)= 2520 us i2c_write(0xc2); i2c_write(2); expandido. i2c_write(32); // Seleccionamos el SD20 // Registro de configuración extandar o control modo i2c_write(0xc2); // Seleccionamos el SD20 i2c_write(22); // Dirección 22H del SD20 Modo expansor de offset(parte Alta) i2c_write(0x); // 460D -->0CCH (Se introduce la parte alta 0H) i2c_write(0xc2); // Seleccionamos el SD20 54
i2c_write(23); Baja) i2c_write(0xcc); // Dirección 23H del SD20 Modo expansor de offset(parte // 460D -->0CCH (Se introduce la parte baja CCH) /* ************************************************** Función Sd20(int8,int8) **************************************************************** */ void Sd20(int8 servo, int8 posicion) { i2c_write(0xc2); i2c_write(servo); i2c_write(posicion); // Seleccionamos el SD20 // Seleccionamos el Servo // Posicionamos el Servo en el extremo A 55
8. Lista de componentes 8.. Bloque control Título: Control.DSN Resistencias Cantidad: Referencia Valor Coste Unitario Coste 2 R,R2 0k 0.05 0.0 7 R3,R4,R7-R 00 0.05 0.35 2 R5,R6 330 0.05 0.0 5 Condensadores Cantidad: Referencia Valor Coste Unitario Coste 4 C0,C,C3,C4 5pF 0.05 0.20 C6 00nF 0.05 0.05 3 Circuitos Integrados. Cantidad: Referencia Valor Coste Unitario Coste U4 PIC6F876_JOAN 5 5 2 SD20 SD20 2.47 2.47 46 Componentes diversos. Cantidad: Referencia Valor Coste Unitario Coste Conector de BAT Bornier 2 0.30 0.30 J,J6-J,J3,J8-J20 CONN-SIL3 0.0. 2 CRISTAL X, X2 2.00 2.00 RESET PULSADOR_JOAN 0.20 0.20 6 J2,J3,J5,J4-J6 J4 Conector de LCD JP MASA CONN-SIL4 CONN-SIL0 CONN-SIL4 BORNIER-2 BORNIER- LCD LCD-6 X 2_JOAN 7 7 RF CEBEK-C-0504_JOAN 7 7 Placa de C.I. 80 x 40 cm. 5 5 2 Zócalo de C.I. 28 patillas 2 Batería 2V/ 8600 ma 35 35 4 Separadores metálicos Macho-Hembra Métrica 3 0.5 2 4 Tuercas Métrica 3 0. 0.4 4 Tornillos Métrica 3 x 0 mm. 0. 0.4 0.5 0.50 0.5 0.5 0.5 0.90 0.50 0.5 0.5 0.5 Coste total 2 Control 0.52 56
8.2. Alimentación / Comunicación µc-pc Título: Alimentación del Circuito + Cargador de Programa. DSN Número de Componentes: 26 3 Resistencia. Cantidad: Referencia Valor Coste Unitario Coste R R38 RV 0k 240 K 0.05 0.05 0.0 0.05 0.05 0.0 0 Condensadores. Cantidad: Referencia Valor Coste Unitario Coste 2 C, C3 2200 uf 0.45 0.90 3 C2, C4,C9 00nF 0.05 0.5 5 C5-C8, C5 uf 0.5 0.45 2 Circuitos Integrados. Cantidad: Referencia Valor Coste Unitario Coste U LM350K U2 MAX232 2 2 4 Diodos. Cantidad: Referencia Valor Coste Unitario Coste 3 D,D2,D4 N4007 0.20 0.60 D3 LED-GREEN 0.20 0.20 7 Componentes diversos. Cantidad: Referencia Valor Coste Unitario Coste JA CONN-SIL0 0.5 0.5 2 J6, JP BORNIER 2 0.5 SW J ON-OFF CONN-D9M Placa C.I. 70x75 cm 6 6 Zócalo de C.I. 6 patillas 0.5 0.5 2 2 Coste total Alimentación del Circuito + Cargador de Programa 6,50 57
8.3. Estructura Título: Cuerpo, brazos y patas.dsn Número de Componentes: 2 2 Componentes diversos. Cantidad: Referencia Valor Coste Unitario Coste Soporte de plástico 80 x 80 cm 8.00 8.00 6 Separadores. 0.20.20 68 Tornillos M3x 40 0.0 6.80 70 Tuercas M3 0.0 7.00 6 8 Chapa dura-aluminio Servos 2.00 6.00 26.00 Coste total 4 245.00 58
9. Coste económico 9.. Desarrollo del proyecto Coste 22 / Hora. 0 Horas de desarrollo Hardware... 220 30 Horas de desarrollo Software... 660 5 Horas de montaje del Prototipo... 330 0 Horas de realización de la Memoria... 220 8 Horas de búsqueda de materiales.... 76 20 Horas de Pruebas.... 440 2046 9.2. Material Alimentación del Circuito + Cargador de Programa 6,50 Control... 0.52 Mando... 3,75 Resto De componentes.... 245,00 394.77 Total.... 2440.77 59
0. Referencias [] Libros: Título: Microcontroladores PIC6F84. Desarrollo de proyectos (2ª Edición) Autores: Enrique Palacios, Fernando Remiro, Lucas J. López. Editorial: Ra_Ma Título: Compilador C CCS y Simulador Proteus para microcontroladores PIC Autores: Eduardo García Breijo Editorial: Marcombo [2] 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 60
. Anexos.. Características principales del PIC 6F876A http://www.datasheetcatalog.org/datasheet/microchip/33023a.pdf.2. Características principales SD20 http://info.hobbyengineering.com/specs/devantech-sd20-tech.pdf 6