proyecto: robot hexápodo -...

proyecto: robot

hexápodo (spidy.00)

Departamento de Electricidad-Electrónica

Ciclo Superior de Desarrollo de Productos Electrónicos

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

2

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


Índice: Página 1. Descripción del proyecto……………………………………………………….. 3 2. Diagrama de bloques………………………………………………………........ 5 3. Análisis de los bloques……………………………………………………....... 6 3.1. 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………………………………………………..10 3.6. Mando emisor radiofrecuencia……………………………………….10 4. Esquemas eléctricos…………………………………………………………..…12 4.1. Bloque control……………………………………………………………….12 4.2. Alimentación/Comunicación µC-PC………………………….....13 5. Diseño de circuitos impresos……………………………………………….14 5.1. Bloque control……………………………………………………………….14 5.2. Alimentación/Comunicación µC-PC……………………………..16 6. Diseño mecánico………………………………………………………………….18 7. Programación………………………………………………………………………19 7.1. Pruebas……………………………………………………………………….19 7.1.1. LCD…………………………………………………………………19 7.1.2 SD20+servos……………………………………………………..20 7.2. Programas………………………………………………………………….38 7.2.1. Inicialización…………………………………………………...38 7.2.2. Andar hacia delante………………………………………...48 8. Lista de componentes…………………………………………………………56 8.1. Bloque control…………………………………………………………….56 8.2. Alimentación / Comunicación µC-PC………………………...57 8.3. Estructura………………………………………………………………….58 9. Coste económico………………………………………………………………..59 10. Referencias………………………………………………………………………..60 11. Anexos……………………………………………………………………………….61 11.1. Características principales del PIC 16F876A…………………61 11.2. Características principales SD20………………………………….61

3



1. 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 PIC16F876A 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.

4



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.

5



2. Diagrama de bloques

CONTROL

CONTROL

SERVOS

LCD

PORT B

I2C

S1..S18

SERVOS

RECEPTOR RF

RC7

ALIMENTACIÓN

5V

COMUNICACIÓN µC-PC

RC6 RC7

HACIA TODAS LAS PLACAS

MANDO

RF

6



3. Análisis de los bloques 3.1. Control + LCD

Un microcontrolador PIC16F876A 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 1 µs.

Está dotado con un pulsador de inicio, un jumper (j 12) 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.

x10

7



3.2. Control PWM servos SD20+ Servo

Este bloque gira en torno a ese chip central. Es un PIC 16F872 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 180° 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.

8



3.3. Alimentación

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 12V. 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 C1, C2, C3 y C4.

Los condensadores C1 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 RV1, la resistencia R38 y el condensador C15. El potenciómetro RV1 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 C15. La resistencia R38 nos proporciona una corriente fija para el potenciómetro RV1 y el condensador C15.

Las funciones de los diodos D1, D2, D3 y D4, son las siguientes.

A K

D11 2

ON-OFF

12

BATERIA

C1

C3

C2100nF

C4

AK

D3V

12

VDD3

AK

D4

AK

D2

12345678910

J1A

12

JP1

1

MASA3

VD

D3

RC

61

RC

71(B

L)

V12

12

3

RV11k

VIN2

VOUT3

ADJ

1

U1

R38

C15

R1

9



El diodo D1, 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, R1 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

12 V, JP1 lleva una tensión fija de 5V y J1A se encarga de de alimentar también uno de los micros de la otra placa.

3.4. Comunicación µC-PC

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 +15V.

Un 1 lógico en TTL equivale a +5V y en RS232 equivale a una tensión comprendida entre -3 y -15V.

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

VC

C

TXPC

RXPC

1

6

2

7

3

8

4

9

5

J11

C5

C8

C6C7

C9

RC71(BL)RC61

VD

D3

T1IN11

R1OUT12

T2IN10

R2OUT9

T1OUT14

R1IN13

T2OUT7

R2IN8

C2+

4

C2-

5

C1+

1

C1-

3

VS+2

VS-6

VCC

16

GND

15

U2

10



3.5. Receptor radiofrecuencia

La Tarjeta Receptora de Datos CEBEK C-0504 es un circuito

híbrido encargado de recibir vía radiofrecuencia, los datos digitales procedentes del Mando. La señal digital tiene que tener una frecuencia entre 20 Hz < fo < 4 KHz. y una portadora de 433,92 MHz. Este circuito demodula la señal de AM obteniendo los datos transmitidos.

3.6. Mando emisor radiofrecuencia

Receptor de Datos CEBEK C-0504

Vcc1

1

GN

D1

2

An

tena

3

GN

D2

7

GN

D3

11

TE

ST

13

Vs

14

Vcc

15

RF2CEBEK-C-0504_JOAN

VCC1(5V)

RC7(RF)

ANTENA

VS

S

RB0E

RB1E

RB2E

RB3E

RB4E

RB1E RB3E RB0E RB2E RB4E

Q1EBD136_JOAN

Emisor de Datos CEBEK C-0503

GN

D1

1

Ve

2

-3

GN

D2

4

An

tena

11

GN

D3

13

Vcc

15

E_RF1E

1

CON1E

BORNIER1_JOAN

VI1

VO3

GN

D2

U2E7805_JOAN

A K

D6E

1N4007_JOAN12

BAT1E9V

RA0/AN02

RA1/AN13

RA2/AN2/VREF-4

RA4/T0CKI6

RA5/AN4/SS7

OSC1/CLKIN9

OSC2/CLKOUT10

RC1/T1OSI/CCP212

RC2/CCP113

RC3/SCK/SCL14

RB7/PGD28

RB6/PGC27

RB526

RB425

RB3/PGM24

RB223

RB122

RB0/INT21

RC7/RX/DT18

RC6/TX/CK17

RC5/SDO16

RC4/SDI/SDA15

RA3/AN3/VREF+5

RC0/T1OSO/T1CKI11

MCLR/Vpp/THV1

U1E

PIC16F876_JOAN

R7E2.2k

X1E

4MHz

C3E

15pF

C4E

15pF

R1E220

R2E220

R3E220

12

SW1E

12

SW3E

12

SW2E

AK

D1ELED-YELLOW_JOAN

AK

D2ELED-GREEN_JOAN

AK

D3ELED-RED_JOAN

R6E220

AK

D7ELED-RED_JOAN

Mando

1 2

SW6E

INTERRUPTOR_JOAN

C2E220uF

VDD

R4E220

12

SW4E

AK

D4ELED-RED_JOAN

R5E220

12

SW5E

AK

D5ELED-RED_JOAN

C1E220uF

VDD

Izquierda Atras Adelante Parar Derecha

11



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

El microcontrolador PIC 16F876a lee los pulsadores y transmite los códigos vía serie a la tarjeta transmisora de radiofrecuencia a una velocidad de 1562,5 baudios por segundo. Es una transmisión asíncrona (1bit de comienzo, 8bit de Datos, 1 bit de parada sin bit de paridad).

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

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

La Tarjeta Emisora SAW para Datos 433,92 MHz. CEBEK C-0503 es un circuito híbrido encargado de transmitir vía radiofrecuencia, los datos digitales procedentes del microprocesador (TX). La señal digital tiene que tener una 20 Hz < fo < 4 KHz. Se modula en AM cuya frecuencia portadora es de 433,92 MHz.

El microcontrolador PIC 16F876a trabaja a una frecuencia de 4 MHz y ejecuta una instrucción en 1uS.

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

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

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

Los condensadores C1 y C2 son filtros.

12



4. Esquemas eléctricos 4.1. Bloque control

13



4.2. Alimentación / Comunicación µC-PC

VC

C

TXPC

RXPC

1

6

2

7

3

8

4

9

5

J11

C5

C8

C6C7

C9

RC71(BL)RC61

VD

D3

T1IN11

R1OUT12

T2IN10

R2OUT9

T1OUT14

R1IN13

T2OUT7

R2IN8

C2+

4

C2-

5

C1+

1

C1-

3

VS+2

VS-6

VCC

16

GND

15

U2

A K

D11 2

ON-OFF

12

BATERIA7.2V

C12200uF

C32200uF

C2100nF

C4100nF

AK

D3

V12

GN

D3

GN

D3

GN

D3

GN

D3

GN

D3

VDD3

GN

D3

GN

D3

AK

D41N4007_JOAN

AK

D2

1N4007_JOAN

12345678910

J1ACONN-SIL10_RODRIGO

12

JP1BORNIER 2_JOAN

VD

D3

RC

61

RC

71(B

L)

GN

D3

VD

D3

GN

D3

12

3

RV11k

VIN2

VOUT3

ADJ

1

U1LM350K_JOAN

R38240

C151uF

GN

D3

R110k

1 2

J6BORNIER 2_JOAN

V12

GN

D3

1

J1

GN

D3

14



5. Diseño de circuitos impresos 5.1. Bloque control

Cara de componentes y Top Copper

15



Bottom Copper

16



5.2. Alimentación / Comunicación µC-PC

Cara de componentes y Top Copper

17



Bottom Copper

18



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. Brazo Mano

Mano Codo Hombro

M

M

M

19



7. Programación 7.1. Pruebas 7.1.1. LCD

1º PRUEBA DEL LCD

/* ************************************************** Control del SD20

************************************************ */

#include <16F876A.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 100 Kbps

// Elegimos sda=PIN_C4 como patilla de datos.

// Elegimos scl=PIN_C3 como patilla de reloj.

#include <LCD1.c> // Incluimos el driver LCD1.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(1,1);

printf(lcd_putc,"I.E.S JOAN MIRO");

lcd_gotoxy(1,1);

printf(lcd_putc,"ROBOT SPYDI");

}

20



7.1.2. SD20 + servos

1º PRUEBA DEL SD20

/* ************************************************** Control del SD20

************************************************ */













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

funcionesa

***************************************************************/





void main()

{

Sd20_ini();

While(1){

// Pata 1:

// Hombro 1.

Sd20(16,100); // Posicionamos el Servo1 del SD20 en 200.

delay_ms(50);

// Codo 1.


delay_ms(50);

// Mano 1.


delay_ms(100);

21




delay_ms(50);


delay_ms(100);


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)/Reg21 +(Reg22,Reg23+20)=

// THmin = Reg22,Reg23 +20 uS = 460uS + 20uS = 480 uS ( 460d --> 1CCH )

// THmax =(256x255)/32 +(460+20)= 2520 uS

i2c_start(); // Inicializa la transmisión

i2c_write(0xC2); // Seleccionamos el SD20

i2c_write(21); // Registro de configuración extandar o control modo

expandido.

i2c_write(32);

i2c_stop(); // Finalización de la transmisión.



i2c_write(22); // Dirección 22H del SD20 Modo expansor de offset(Parte

Alta)

i2c_write(0x1); // 460D -->01CCH (Se introduce la parte alta 01H)





Baja)

i2c_write(0xCC); // 460D -->01CCH (Se introduce la parte baja CCH)


}

/* ********************** Función Sd20(int8,int8)

************************** */

void Sd20(int8 servo, int8 posicion)

{

22





i2c_write(servo); // Seleccionamos el Servo1

i2c_write(posicion); // Posicionamos el Servo en el extremo A


}

2º prueba del SD20 /* ************************************************** Control del SD20

************************************************ */











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

funcionesa

***************************************************************/





void main()

{

Sd20_ini();

// centrado de los servos

While(1)

{

// centrado uña



23




while(1);

}

}

/* ******************************************************** Función

Sd20_ini

**************************************************************** */


{


2,520 mS.




// THmax =(256x255)/32 +(460+20)= 2520 uS




expandido.

i2c_write(32);





Alta)






Baja)



}

24



/* ************************************************** Función

Sd20(int8,int8)

**************************************************************** */


{






}

3º PRUEBA DEL SD20

/* ************************************************** Control del SD20

************************************************ */













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

funcionesa

***************************************************************/





void main()

{

25



Sd20_ini();


{

lcd_gotoxy(1,1);


delay_ms(2500);

lcd_gotoxy(1,1);


delay_ms(2500);

lcd_gotoxy(4,1);

printf(lcd_putc,"coco y");

lcd_gotoxy(4,2);

printf(lcd_putc,"txus");

delay_ms(2500);

Sd20_ini();

While(1)

// Pata 1:

// Hombro 1.


delay_ms(50);

// Codo 1.


delay_ms(50);

// Mano 1.


delay_ms(100);


delay_ms(50);


delay_ms(100);


delay_ms(50);

}

}

/* ******************************************************** Función

Sd20_ini

**************************************************************** */


26



{


2,520 mS.




// THmax =(256x255)/32 +(460+20)= 2520 uS




expandido.

i2c_write(32);





Alta)






Baja)



}

/* ************************************************** Función

Sd20(int8,int8)

**************************************************************** */


{






}

27



4º PRUEBA DEL SD20

/* ************************************************** Control del SD20

************************************************ */













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

funcionesa

***************************************************************/





void main()

{

Sd20_ini();


While(1)

{

lcd_gotoxy(1,1);


//delay_ms(2500);

lcd_gotoxy(1,2);


// delay_ms(2500);

28



// centrado codo







// centrado hombro







// centrado mano







delay_ms(500);

// LEVANTANDO


29








while(1);

}

}

/* ******************************************************** Función

Sd20_ini

**************************************************************** */


{


2,520 mS.




// THmax =(256x255)/32 +(460+20)= 2520 uS




expandido.

i2c_write(32);





Alta)





30




Baja)



}

/* ************************************************** Función

Sd20(int8,int8)

**************************************************************** */


{






}

5º PRUEBA DEL ROBOT (CENTRANDO TODOS LAS PATAS)

/* ************************************************** Control

del SD20 ************************************************ */




#use i2c(Master, force_hw, slow, sda=PIN_C4, scl=PIN_C3) //

Configuración de I2C


// Forzamos a trabajar con su

hardware interno.(Asociado a I2C)

// Trabajamos a velocidad baja 100

Kbps

// Elegimos sda=PIN_C4 como

patilla de datos.

// Elegimos scl=PIN_C3 como

patilla de reloj.

#include <LCD1.c> // Incluimos el driver

LCD1.c que contiene las funciones de control del LCD.

/* ******************************************************

Declaración de funcionesa

***************************************************************/



31



/* ******************************************************

Función principal o programa principal

************************************************ */

void main(){

int i,j;

Sd20_ini();


lcd_gotoxy(1,1);


//delay_ms(2500);

lcd_gotoxy(1,2);


// delay_ms(2500);

//centrado hombro

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

Sd20(i, 127);

}

//centrado codo

for(i=2; i<19; i=i+3){

Sd20(i, 127);

}

//centrdo mano

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

Sd20(i, 96);

}

for(i=12; i<20; i=i+3){

Sd20(i, 160);

}

delay_ms(200);

Sd20(1, 127);

Sd20(3, 174);

Sd20(2, 174);

32



Sd20(7, 127);

Sd20(9, 174);

Sd20(8, 174);

delay_ms(200);

Sd20(1, 80);

Sd20(3, 174);

Sd20(2, 174);

Sd20(7, 174);

Sd20(9, 174);

Sd20(8, 174);

delay_ms(200);

Sd20(1, 80);

Sd20(3, 127);

Sd20(2, 127);

Sd20(7, 174);

Sd20(9, 127);

Sd20(8, 127);

delay_ms(200);

Sd20(10, 127);

Sd20(12, 80);

Sd20(11, 80);

Sd20(16, 127);

Sd20(18, 80);

Sd20(17, 80);

delay_ms(200);

Sd20(10, 80);

Sd20(12, 80);

Sd20(11, 80);

Sd20(16, 174);

Sd20(18, 80);

Sd20(17, 80);

delay_ms(200);

Sd20(10, 80);

Sd20(12, 127);

Sd20(11, 127);

33



Sd20(16, 174);

Sd20(18, 127);

Sd20(17, 127);

}

/* ********************************************************

Función Sd20_ini

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

*/


{

// Fijamos el rango de trabajo de los servor desde THmin= 0,480 mS

hasta THmax= 2,520 mS.



// THmin = Reg22,Reg23 +20 uS = 460uS + 20uS = 480 uS ( 460d -->

1CCH )

// THmax =(256x255)/32 +(460+20)= 2520 uS



i2c_write(21); // Registro de configuración extandar o

control modo expandido.

i2c_write(32);




i2c_write(22); // Dirección 22H del SD20 Modo expansor

de offset(Parte Alta)

i2c_write(0x1); // 460D -->01CCH (Se introduce la parte

alta 01H)




i2c_write(23); // Dirección 23H del SD20 Modo expansor

de offset(Parte Baja)

i2c_write(0xCC); // 460D -->01CCH (Se introduce la parte

baja CCH)


}

34



/* **************************************************

Función Sd20(int8,int8)

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

*/


{






}

PRUEBA DE RANGO DE MOVIMIENTOS MAXIMOS Y MINIMOS

/* ************************************************** Control del SD20

************************************************ */













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

funcionesa

***************************************************************/





void main(){

int i;

35



Sd20_ini();


lcd_gotoxy(1,1);


//delay_ms(2500);

lcd_gotoxy(1,2);


// delay_ms(2500);

//centrado hombro

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

Sd20(i, 127);

}

//centrado codo

for(i=2; i<19; i=i+3){

Sd20(i, 127);

}

//centrdo mano

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

Sd20(i, 127);

}

delay_ms(500);

//maximo codo

Sd20(2, 200);

Sd20(17, 55);

delay_ms(100);

Sd20(3,65);

Sd20(18,190);

delay_ms(500);

//minimo codo

Sd20(2, 55);

Sd20(17, 200);

delay_ms(100);

Sd20(3,127);

Sd20(18, 127);

}

36



/* ******************************************************** Función

Sd20_ini

**************************************************************** */


{


2,520 mS.




// THmax =(256x255)/32 +(460+20)= 2520 uS




expandido.

i2c_write(32);





Alta)






Baja)



}

/* ************************************************** Función

Sd20(int8,int8)

**************************************************************** */


37



{






}

38



7.2. Programas

INICIO: LEVANTANDO EL ROBOT Y SALUDANDO

/* ************************************************** Control del SD20

************************************************ */













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

funcionesa

***************************************************************/





void main(){

int i, j, k, l, aux;

Sd20_ini();


lcd_gotoxy(1,1);


//delay_ms(2500);

lcd_gotoxy(1,2);


// delay_ms(2500);

//centrado hombro

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

39



Sd20(i, 127);

}

//centrado codo

for(i=2; i<10; i=i+3){ //DERECHA

Sd20(i, 94);

}

for(i=11; i<19; i=i+3){ //IZQUIERDA

Sd20(i, 160);

}

//centrdo mano

for(i=3; i<10; i=i+3){ //DERECHA

Sd20(i, 94);

}

for(i=12; i<20; i=i+3){ //IZQUIERDA

Sd20(i, 160);

}

delay_ms(5000);

// codo

for(aux=0; aux<130; aux++){

delay_ms(1);

j= 94+aux;

k= 160-aux;

for(i=2; i<10; 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(11, 30);

Sd20(14, 30);

Sd20(17, 30);

delay_ms(10);

40



//mano

Sd20(3,200);

Sd20(6,200);

Sd20(9,200);

Sd20(12,55);

Sd20(15,55);

Sd20(18,55);

delay_ms(500);

//centrado hombro

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

Sd20(i, 127);

}

//centrado codo

for(i=2; i<19; i=i+3){

Sd20(i, 127);

}

//centrdo mano

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

Sd20(i, 96);

}

for(i=12; i<20; i=i+3){

Sd20(i, 160);

}

delay_ms(1000);

Sd20(5, 150);

Sd20(14,104);

delay_ms(200);

Sd20(4, 150);

Sd20(15,150);

delay_ms(200);

Sd20(16, 100);

Sd20(17,50);

while(1){

Sd20(18, 180);

41



delay_ms(100);

Sd20(18,60);

delay_ms(100);

}

}

/* ******************************************************** Función

Sd20_ini

**************************************************************** */


{


2,520 mS.




// THmax =(256x255)/32 +(460+20)= 2520 uS




expandido.

i2c_write(32);





Alta)






Baja)


42




}

/* ************************************************** Función

Sd20(int8,int8)

**************************************************************** */


{






}

1º INTENTO DE ANDAR

/*************************************************** Control del SD20

************************************************ */













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

funcionesa

***************************************************************/





43



void main(){

int i,j;

Sd20_ini();


lcd_gotoxy(1,1);


//delay_ms(2500);

lcd_gotoxy(1,2);


// delay_ms(2500);

// centrado patas

//centrado hombro

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

Sd20(i, 127);

}

//centrado codo

for(i=2; i<10; i=i+3){

Sd20(i, 96);

}

for(i=11; i<20; i=i+3){

Sd20(i, 160);

}

//centrdo mano

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

Sd20(i, 96);

}

for(i=12; i<20; i=i+3){

Sd20(i, 160);

}

// Preparacion de servos para andar

delay_ms(200);

//centrado 1º y 3º pata

Sd20(1, 127);

Sd20(3, 174);

Sd20(2, 174);

Sd20(7, 127);

Sd20(9, 174);

Sd20(8, 174);

44



delay_ms(200);


Sd20(1, 80);

Sd20(3, 174);

Sd20(2, 174);

Sd20(7, 174);

Sd20(9, 174);

Sd20(8, 174);

delay_ms(200);


Sd20(1, 80);

Sd20(3, 96);

Sd20(2, 96);

Sd20(7, 174);

Sd20(9, 96);

Sd20(8, 96);

delay_ms(200);


Sd20(10, 127);

Sd20(12, 80);

Sd20(11, 80);

Sd20(16, 127);

Sd20(18, 80);

Sd20(17, 80);

delay_ms(200);


Sd20(10, 80);

Sd20(12, 80);

Sd20(11, 80);

Sd20(16, 174);

Sd20(18, 80);

Sd20(17, 80);

delay_ms(200);


Sd20(10, 80);

Sd20(12, 160);

Sd20(11, 160);

Sd20(16, 174);

Sd20(18, 160);

45



Sd20(17, 160);

delay_ms(600);

while(1){

// adelante patas 1,3,5

Sd20(1, 127);

Sd20(3, 174);

Sd20(2, 174);

delay_ms(100);

Sd20(7, 219);

Sd20(9, 174);

Sd20(8, 174);

delay_ms(100);

Sd20(13, 80);

Sd20(15, 80);

Sd20(14, 80);

delay_ms(200);

Sd20(1, 127);

Sd20(3, 96);

Sd20(2, 96);

delay_ms(100);

Sd20(7, 219);

Sd20(9, 96);

Sd20(8, 96);

delay_ms(100);

Sd20(13, 80);

Sd20(15, 160);

Sd20(14, 160);

// adelante patas 2.4.6

delay_ms(200);

Sd20(4, 174);

Sd20(6, 174);

Sd20(5, 174);

delay_ms(100);

Sd20(10, 33);

Sd20(12, 80);

Sd20(11, 80);

delay_ms(100);

Sd20(16, 127);

Sd20(18, 80);

Sd20(17, 80);

46



delay_ms(200);

Sd20(4, 174);

Sd20(6, 96);

Sd20(5, 96);

delay_ms(100);

Sd20(10, 33);

Sd20(12, 160);

Sd20(11, 160);

delay_ms(100);

Sd20(16, 127);

Sd20(18, 160);

Sd20(17, 160);

// reset inicial

delay_ms(600);

Sd20(1, 80);

Sd20(3, 96);

Sd20(2, 96);

Sd20(7, 174);

Sd20(9, 96);

Sd20(8, 96);

Sd20(4, 127);

Sd20(6, 96);

Sd20(5, 96);

Sd20(10, 80);

Sd20(12, 160);

Sd20(11, 160);

Sd20(16, 174);

Sd20(18, 160);

Sd20(17, 160);

Sd20(13, 127);

Sd20(15, 160);

Sd20(14, 160);

delay_ms(200);

}

}

47



/* ******************************************************** Función

Sd20_ini

**************************************************************** */


{


2,520 mS.




// THmax =(256x255)/32 +(460+20)= 2520 uS




expandido.

i2c_write(32);





Alta)






Baja)



}

/* ************************************************** Función

Sd20(int8,int8)

**************************************************************** */


{


48







}

MOVIMIENTO DE ANDAR HACIA DELANTE

/*************************************************** Control del SD20

************************************************ */













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

funcionesa

***************************************************************/





void main(){

int i,j;

Sd20_ini(); // Inicializamos el Sd20.


lcd_gotoxy(1,1);


//delay_ms(2500);

49



lcd_gotoxy(1,2);


// delay_ms(2500);

// centrado patas

//centrado hombro

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

Sd20(i, 127);

}

//centrado codo

for(i=2; i<10; i=i+3){

Sd20(i, 96);

}

for(i=11; i<20; i=i+3){

Sd20(i, 160);

}

//centrdo mano

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

Sd20(i, 96);

}

for(i=12; i<20; i=i+3){

Sd20(i, 160);

}

// Preparacion de servos para andar

delay_ms(200);

while(1){

// pata 6.

// Realizara su movmiento habitual mientras el resto de patas realizaran un

movmiento pararlelo

delay_ms(100);

Sd20(16, 127);

Sd20(18, 80);

Sd20(17, 80);

Sd20(7, 94);

50



Sd20(9, 87);

Sd20(8, 96);

Sd20(10, 160);

Sd20(12, 196);

Sd20(11, 160);

Sd20(4, 129);

Sd20(6, 96);

Sd20(5, 96);

Sd20(1, 100);

Sd20(3, 96);

Sd20(2, 96);

Sd20(13, 98);

Sd20(15, 160);

Sd20(14, 160);

delay_ms(100);

Sd20(16, 127);

Sd20(18, 160);

Sd20(17, 160);

delay_ms(100);

//pata 2


movmiento pararlelo

Sd20(4, 174);

Sd20(6, 174);

Sd20(5, 174);

Sd20(16, 136);

Sd20(18, 160);

Sd20(17, 160);

Sd20(7, 94);

Sd20(9, 78);

Sd20(8, 96);

Sd20(10, 160);

Sd20(12, 205);

Sd20(11, 160);

Sd20(1, 91);

51



Sd20(3, 96);

Sd20(2, 96);

Sd20(13, 107);

Sd20(15, 160);

Sd20(14, 160);

delay_ms(100);

Sd20(4, 174);

Sd20(6, 96);

Sd20(5, 96);

delay_ms(100);

//pata 4


movmiento pararlelo

Sd20(10, 160);

Sd20(12, 80);

Sd20(11, 80);

Sd20(16, 145);

Sd20(18, 160);

Sd20(17, 160);

Sd20(7, 94);

Sd20(9, 69);

Sd20(8, 96);

Sd20(1, 82);

Sd20(3, 96);

Sd20(2, 96);

Sd20(13, 116);

Sd20(15, 160);

Sd20(14, 160);

delay_ms(100);

Sd20(10, 160);

Sd20(12, 160);

Sd20(11, 160);

delay_ms(100);

//pata 1

52




movmiento pararlelo

Sd20(1, 127);

Sd20(3, 174);

Sd20(2, 174);

Sd20(16, 154);

Sd20(18, 160);

Sd20(17, 160);

Sd20(7, 94);

Sd20(9, 60);

Sd20(8, 96);

Sd20(10, 160);

Sd20(12, 169);

Sd20(11, 160);

Sd20(4, 156);

Sd20(6, 96);

Sd20(5, 96);

Sd20(13, 125);

Sd20(15, 160);

Sd20(14, 160);

delay_ms(100);

Sd20(1, 127);

Sd20(3, 96);

Sd20(2, 96);

delay_ms(100);

//pata 5


movmiento pararlelo

Sd20(13, 80);

Sd20(15, 80);

Sd20(14, 80);

Sd20(16, 163);

Sd20(18, 160);

Sd20(17, 160);

Sd20(7, 94);

Sd20(9, 51);

53



Sd20(8, 96);

Sd20(10, 160);

Sd20(12, 178);

Sd20(11, 160);

Sd20(4, 147);

Sd20(6, 96);

Sd20(5, 96);

Sd20(1, 118);

Sd20(3, 96);

Sd20(2, 96);

delay_ms(100);

Sd20(13, 80);

Sd20(15, 160);

Sd20(14, 160);

delay_ms(100);

//pata 3


movmiento pararlelo

Sd20(7, 94);

Sd20(9, 174);

Sd20(8, 174);

Sd20(16, 172);

Sd20(18, 160);

Sd20(17, 160);

Sd20(10, 160);

Sd20(12, 187);

Sd20(11, 160);

Sd20(4, 138);

Sd20(6, 96);

Sd20(5, 96);

Sd20(1, 109);

Sd20(3, 96);

Sd20(2, 96);

Sd20(13, 89);

Sd20(15, 160);

Sd20(14, 160);

54



delay_ms(100);

Sd20(7, 94);

Sd20(9, 96);

Sd20(8, 96);

}

}

/* ******************************************************** Función

Sd20_ini

**************************************************************** */


{


2,520 mS.




// THmax =(256x255)/32 +(460+20)= 2520 uS




expandido.

i2c_write(32);





Alta)





55




Baja)



}

/* ************************************************** Función

Sd20(int8,int8)

**************************************************************** */


{






}

56



8. Lista de componentes 8.1. Bloque control Título: Control.DSN

11 Resistencias

Cantidad: Referencia Valor Coste Unitario Coste

2 R1,R2 10k 0.05 0.10

7 R3,R4,R7-R11 100 0.05 0.35

2 R5,R6 330 0.05 0.10

5 Condensadores


4 C10,C11,C13,C14 15pF 0.05 0.20

1 C16 100nF 0.05 0.05

3 Circuitos Integrados.


1 U4 PIC16F876_JOAN 5 5

2 SD20 SD20 21.47 21.47

46 Componentes diversos.


1 Conector de BAT1 Bornier 2 0.30 0.30

11 J1,J6-J11,J13,J18-J20 CONN-SIL3 0.10 1.1

2 CRISTAL X1, X2 2.00 2.00

1 RESET PULSADOR_JOAN 0.20 0.20

6

1

J2,J3,J5,J14-J16

J4

CONN-SIL4

CONN-SIL10

0.15

0.50

0.90

0.50

1

1

1

Conector de LCD1

JP

MASA

CONN-SIL14

BORNIER-2

BORNIER-1

0.15

0.15

0.15

0.15

0.15

0.15

1 LCD1 LCD-16 X 2_JOAN 7 7

1 RF1 CEBEK-C-0504_JOAN 7 7

1 Placa de C.I. 180 x 140 cm. 15 15

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

1 Batería 12V/ 8600 mA 35 35

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

4 Tuercas Métrica 3 0.1 0.4

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

Coste total 2 Control 101.52 €

57



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.


1

1

1

R1

R38

RV1

10k

240

1K

0.05

0.05

0.10

0.05

0.05

0.10

10 Condensadores.


2 C1, C3 2200 uF 0.45 0.90

3 C2, C4,C9 100nF 0.05 0.15

5 C5-C8, C15 1uF 0.15 0.45

2 Circuitos Integrados.


1 U1 LM350K 1 1

1 U2 MAX232 2 2

4 Diodos.


3 D1,D2,D4 1N4007 0.20 0.60

1 D3 LED-GREEN 0.20 0.20



1 J1A CONN-SIL10 0.5 0.5

2 J6, JP1 BORNIER 2 0.5 1

1

1

SW1

J11

ON-OFF

CONN-D9M

1

2

1

2

1 Placa C.I. 70x75 cm 6 6

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

Coste total 1 Alimentación del Circuito + Cargador de Programa 16,50 €

58



8.3. Estructura Título: Cuerpo, brazos y patas.DSN

Número de Componentes: 12



1 Soporte de plástico 80 x 80 cm 8.00 8.00

6 Separadores. 0.20 1.20

68 Tornillos M3x 40 0.10 6.80

70 Tuercas M3 0.10 7.00

6

18

Chapa dura-aluminio

Servos

1

12.00

6.00

216.00

Coste total 4 245.00€

59



9. Coste económico 9.1. Desarrollo del proyecto Coste 22 € / Hora.

10 Horas de desarrollo Hardware….............................. 220 €

30 Horas de desarrollo Software................................... 660 €

15 Horas de montaje del Prototipo…............................. 330 €

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

8 Horas de búsqueda de materiales. ........................... 176 €

20 Horas de Pruebas. …................................................. 440€ ______ 2046 €

9.2. Material

Alimentación del Circuito + Cargador de Programa… 16,50 €

Control.......................................................................... 101.52 €

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

Resto De componentes. ............................................. 245,00 € _______

394.77 € Total. ............................................................................................... 2440.77 €

60



10. Referencias [1] Libros: Título: Microcontroladores PIC16F84. 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

http://www.ditronic.com/

http://www.microcontroladores.com/

61



11. Anexos 11.1. Características principales del PIC 16F876A http://www.datasheetcatalog.org/datasheet/microchip/33023a.pdf

11.2. Características principales SD20

http://info.hobbyengineering.com/specs/devantech-sd20-tech.pdf

http://www.datasheetcatalog.org/datasheet/microchip/33023a.pdf

http://info.hobbyengineering.com/specs/devantech-sd20-tech.pdf

proyecto: robot hexápodo -...

Documents

Transcript of proyecto: robot hexápodo -...