126

CONCLUSIONES

La robótica es sin duda un área de interés de las investigaciones de la

actualidad, con esta investigación se estudio sobre los robots manipuladores

donde, se pudo apreciar un desarrollo completo desde la identificación de

una necesidad, hasta llevar a cabo la construcción de un prototipo,

contemplando a grandes rasgos una solución con una estructura mecánica

de brazo robótico de 5 grados de libertad, su estudio matemático de

cinemática directa e inversa para finalmente desarrollar un control cinemático

que se encarga de los movimientos y control de trayectoria.

Para el cumplimiento del objetivo principal de la tesis, se determinó que el

tipo de robot angular es el que mejor se adapta a las tareas de movilización,

de igual manera se propuso una célula de trabajo de robot en el centro para

que pudiese interactuar, tal cual como lo hace un operador de planta en la

actualidad, donde este toma una pieza, la coloca en el troquel, la procesa

para después poner esa misma pieza en una canasta para que este sea

procesado en otras actividades, igualmente se analizo las reglas

matemáticas para poder modelar el robot industrial y poder contemplar su

movimiento en el espacio cartesiano y en el espacio articular con el fin de

que este pueda realizar tareas especificas de movimiento con cierta

precisión.

Una vez realizado su estudio cinemático se desarrollo el control

cinemático a partir de la generación de trayectorias con interpolaciones

127

cubicas entre puntos adyacentes para asegurar un movimiento suave sin

cambios bruscos, se implemento el control embebido en un microcontrolador

PIC18F4550, así mismo y para poderle suministrar las instrucciones al robot

industrial, se desarrollo un sistema de programación del robot, el cual se

contruyo bajo el esquema de programación textual, para el cual se definió

una serie de comandos que el operador podrá usar para definir la orientación

y trayectoria que debe seguir la pinza del robot.

Se cumplió con el objetivo principal de este estudio con éxito ya que el

robot industrial funciona correctamente y es una herramienta de gran utilidad

ya que se puede adaptar fácilmente a las actividades de una empresa

manufacturera, partiendo de los comandos ingresados en el programa del

mismo, siendo este una alternativa tecnológica al alcance de la pequeña y

mediana empresa para automatizar el proceso de conformado de piezas en

prensas troqueladoras, incrementando la seguridad y productividad del

proceso.

128

RECOMENDACIONES

Según la experiencia obtenida con el diseño del control cinemático y su

implementación en un microcontrolador PIC18F4550, se plantea la primera

recomendación, que es utilizar un dspic o un microcontrolador de 24 o32 bits

para tener los suficientes recursos para implementar con mayor precisión y

rapidez las operaciones aritméticas y así agilizar el calculo de las mismas y a

la vez aumentar el rendimiento del control de trayectorias.

De igual manera al aumentar los recursos de procesamiento con un mejor

micro, también se recomienda que este posea mayor cantidad de memoria,

la cual se pueda usar para aumentar la cantidad de órdenes de un trabajo

que deba realizar el robot en actividades complejas.

Para implementaciones robustas en aplicaciones industriales como las

actividades de soldadura o corte guiado se recomienda usar adicionalmente

otra estrategia de control combinando un control dinámico sobre las

referencias que suministra el control cinemático.

En cuanto al hardware se recomienda modificar los sensores y sus

codificadores, aumentando la resolución de lo mismos, para optimizar la

precisión en los cálculos y mejorar el rendimiento general del control.

129

REFERENCIAS BIBLIOGRAFICAS

Libros

Angeles, J., (2007). “Fundamentals of Robotic Mechanical Systems”, 3ra

Edición, Editorial Springer, U.S.A.

Angulo, J., Romero S., Angulo, I., (2006). “Microcontroladores PIC Diseño

Practico de Aplicaciones 2da Parte: PIC16F87X y PIC18FXXX”, 2da

Edición, Editorial McGRAW-HILL, España.

Arias, F., (1999). “El Proyecto de Investigación”, 2ra Edición, Editorial

Episteme, Venezuela.

Axelson, J., (2005). “USB Complete: Everything You Need to Develop

Custom USB Peripherals”, 3ra Edición, Lakeview Research LLC, U.S.A.

Barr, M., Massa, A., (2006), “Programming Embedded Systems”, 1ra Edición,

Editorial O’Reilly. U.S.A.

Barrientos, A., Peñin, L. F., Balaguer, C., Aracil, R., (2007), “Fundamentos de

Robótica”, 2da Edición, Editorial McGraw-HILL. España.

Craig, J., (1989), “Introduction to Robotics: Mechanics and Control”, 2da

Edición, Editorial Addison-Wesley Publishing Company, Inc. U.S.A.

Fu, K., González, R., Lee, C., (1987), “Robótica: Control, sensores, visión e

inteligencia”, 2da Edición, Editorial McGraw-HILL. México.

Groove, M. P., Weiss, M. R., Odrey, N., (1989), “Robótica Industrial:

Tecnología, Programación y Aplicaciones”, 1ra Edición, Editorial

McGraw-HILL. España.

130

Kelly, R., Santibáñez, V., (2003), “Control de Movimiento de Robots

Manipuladores”, 1ra Edición, Editorial Prentice Hall. España.

Lewis, P, H., Yang, S., (1999), “Sistemas de Control en Ingeniería”, 1ra

Edición, Editorial Prentice Hall. España.

Ogata, K., (1998), “Ingeniería de Control Moderna”, 3ra Edición, Editorial

Prentice Hall, México.

Ollero, A., (2007). “Robótica: Manipuladores y Robots Móviles”, 1ra Edición,

Editorial Marcombo-Alfaomega, México.

Renteria, A., Rivas M., (2000). “Robótica Industrial, Fundamentos y

Aplicaciones”, 1ra Edición, Editorial McGRAW-HILL, España.

Sampieri, R., Collado, C., (1991). “Metodología de la Investigación”, 1ra

Edición, Editorial McGRAW-HILL, México.

Torres, F., Pomares, J., Gil, P., Puente, S. T., Aracil, R., (2002), “Robots y

Sistemas Sensoriales”, 2da Edición, Editorial Prentice Hall. España.

Trabajos de Investigación

Campa, R., (2005). “Control de Robots Manipuladores en Espacio de Tarea”,

Tesis doctoral realizada en el Centro de Investigación Científica y de

Educación Superior de Ensenada, Baja California, México.

Jaramillo, F., (1999), “Plataforma para el ensayo de algoritmos de control

para un robot manipulador”, Tesis de maestría realizada en el Centro de

131

Investigación Científica y de Educación Superior de Ensenada, Baja

California, México.

Marquez, L., (1994). “Control de Robots Manipuladores Utilizando

Retroalimentación Visual”, Tesis de maestría realizada en el Centro de

Investigación Científica y de Educación Superior de Ensenada, Baja

California, México.

Moreno, E., (1999), “Control de Robots Manipuladores Mediante Campo de

Velocidad”, Tesis de maestría realizada en el Centro de Investigación

Científica y de Educación Superior de Ensenada, Baja California,

México.

Olcay, P., (2010), “Sistema De Control de un Manipulador para un ROV

(Remotely Operated Vehicle)”, Tesis de maestría del Instituto

Panamericano de Ingeniería Naval, Chile.

Sirit, Y., Fernandez, J., Lubo, A., (2002). “Accidentes de la Mano en

Trabajadores de la Costa Oriental del Lago de Maracaibo del Estado

Zulia, Venezuela 1986-1993”, Investigación clínica, vol.43, no.2, de la

Universidad del Zulia, Venezuela.

Sobrado, E., (2003). “Sistema De Visión Artificial Para El Reconocimiento Y

Manipulación De Objetos Utilizando Un Brazo Robot”, Tesis de maestría

desarrollada en la Pontificia Universidad Católica del Perú, Perú.

ANEXOS A

Área de Troqueles de Gurimetal C.A

Área de Prensas Troqueladoras de Gurimetal C.A

Prensas Troqueladoras de Gurimetal C.A

ANEXOS B

Piezas en SolidWorks del Ensamble del Robot Industrial

Base del Robot Industrial y Electrónica

Detalle del Brazo del Robot Industrial y Pinza

Detalle de la Pinza del Robot Industrial

Vista Superior del Robot Industrial

Vista Lateral del Robot Industrial

Vista Transversal del Robot Industrial

ANEXOS C

Especificaciones Técnicas de los Servomotores Hitec

ANEXOS D

Especificaciones Técnicas de las Piezas Electrónicas

Conector USB tipo A

Disposición pines conector USB tipo A

donde: 1=Vbus 2=D- 3=D+ 4=Gnd

ANEXOS E

Código del Programa de Control

Fichero pic_brazo_robot.c

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //// pic_brazo_robot //// //// //// //// //// //// Realizado con el compilador CCS PCWH 4.023 //// //// //// //// Por: Ing. Omar León leon.omar82@gmail.com //// //// //// //// Robot Industrial para la Automatización del porceso de conformado //// //// de piezas en Prensas Troqueladoras //// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #include <18F4550.h> #DEVICE ADC=10 // cad a 10 bits, justificación a a la derecha #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,VREGEN #use delay(clock=48000000) //configuramos la velocidad del micro a 48 MHz #use fast_io(B) #define USB_HID_DEVICE FALSE //deshabilitamos el uso de las directivas HID #define USB_EP1_TX_ENABLE USB_ENABLE_BULK //turn on EP1(EndPoint1) for IN bulk/interrupt transfers #define USB_EP1_RX_ENABLE USB_ENABLE_BULK //turn on EP1(EndPoint1) for OUT bulk/interrupt transfers #define USB_EP1_TX_SIZE 10 //tamano en bytes que envia al programa 2 por cada sensor y 2 para instruccion #define USB_EP1_RX_SIZE 20 //tamano en bytes que recibe del programa 2 por cada servo, 2 para instruccion y 6 para velocidad //solo vamos a configurar 8 servomotores digitales como maximo para el brazo robotico //en realidad solo se usaran 2, que son los large servo del hombro y codo del brazo #define SERVO1 PIN_B0 #define SERVO2 PIN_B1 #define SERVO3 PIN_B2 #define SERVO4 PIN_B3 #define SERVO5 PIN_B4 #define SERVO6 PIN_B5 #define SERVO7 PIN_B6 #define SERVO8 PIN_B7 #define lineas_programa 20 #priority timer1 const int16 ra = 133; const int16 Ticks4Window = 30012; // PWM Window for servo = 2.5 ms x 8 = 20 ms 2.5/0.0000833=30012.00 const int16 Ticks4Minimum = 10800; // PWM High for Minimum Position = 0.9 ms 0.9/0.0000833=10804.32 const int16 Ticks4Center = 18000; // PWM High for Center Position = 1.5 ms 1.5/0.0000833=18007.20 const int16 Ticks4Maximum = 25210; // PWM High for Maximum Position = 2.1 ms 2.1/0.0000833=25210.08 //const int16 TicksTotal = 65535; const int16 TicksTotal = 65640; // se modifico para poner exactos 20 ms //configuramos los tiempos iniciales para cada uno de los servos a utilizar //valores calculados con el software de configuracion robotico v1.0 //para este caso tenemos una precision muy alta de 0.0075 grados de resolucion aprox //establecemos por defecto un punto de reset const int16 Ticks4Servo01 = 18000; const int16 Ticks4Servo02 = 21000; const int16 Ticks4Servo03 = 27000; const int16 Ticks4Servo04 = 21000; const int16 Ticks4Servo05 = 15900; const int16 Ticks4Servo06 = 13000; //establesco el equivalente a 1.5 ms punto medio de los servos, por estandarizacion solo //estos son unsigned long

int16 Ticks4Servo01_medio = 18000; int16 Ticks4Servo02_medio = 13000; int16 Ticks4Servo03_medio = 19000; int16 Ticks4Servo04_medio = 21000; int16 Ticks4Servo05_medio = 15900; int16 Ticks4Servo06_medio = 13000; //variables con los limites superiores e inferiores de los servos, se colocan por defecto int16 Ticks4Servo01_sup = 25500; int16 Ticks4Servo02_sup = 21000; int16 Ticks4Servo03_sup = 27000; int16 Ticks4Servo04_sup = 28400; int16 Ticks4Servo05_sup = 27000; int16 Ticks4Servo06_sup = 22000; int16 Ticks4Servo01_inf = 7000; int16 Ticks4Servo02_inf = 10800; int16 Ticks4Servo03_inf = 15900; int16 Ticks4Servo04_inf = 8500; int16 Ticks4Servo05_inf = 5500; int16 Ticks4Servo06_inf = 8000; static int16 Servo_PWM[8]={Ticks4Servo01,Ticks4Servo02,Ticks4Servo03,Ticks4Servo04,Ticks4Servo05,Ticks4Servo06,Ticks4Center,Ticks4Center}; static int8 Servo_Idx=0; static int1 SERVO1_ON=1; static int1 SERVO2_ON=1; static int1 SERVO3_ON=1; static int1 SERVO4_ON=1; static int1 SERVO5_ON=1; static int1 SERVO6_ON=1; static int1 SERVO7_ON=0; static int1 SERVO8_ON=0; static int1 flag_Phase; //indica si esta la senal en 0 o en 1 static int16 Ticks4NextInterrupt=35536; //a 48Mhz segun calculadora de RedRaven #int_timer1 void timer1_isr(void) { if(flag_Phase==0) { if(Servo_Idx==0 && SERVO1_ON) output_high(SERVO1); if(Servo_Idx==1 && SERVO2_ON) output_high(SERVO2); if(Servo_Idx==2 && SERVO3_ON) output_high(SERVO3); if(Servo_Idx==3 && SERVO4_ON) output_high(SERVO4); if(Servo_Idx==4 && SERVO5_ON) output_high(SERVO5); if(Servo_Idx==5 && SERVO6_ON) output_high(SERVO6); if(Servo_Idx==6 && SERVO7_ON) output_high(SERVO7); if(Servo_Idx==7 && SERVO8_ON) output_high(SERVO8); Ticks4NextInterrupt = TicksTotal - Servo_PWM[Servo_Idx]; set_timer1(Ticks4NextInterrupt); } if(flag_Phase==1) { if(Servo_Idx==0 && SERVO1_ON)

output_low(SERVO1); if(Servo_Idx==1 && SERVO2_ON) output_low(SERVO2); if(Servo_Idx==2 && SERVO3_ON) output_low(SERVO3); if(Servo_Idx==3 && SERVO4_ON) output_low(SERVO4); if(Servo_Idx==4 && SERVO5_ON) output_low(SERVO5); if(Servo_Idx==5 && SERVO6_ON) output_low(SERVO6); if(Servo_Idx==6 && SERVO7_ON) output_low(SERVO7); if(Servo_Idx==7 && SERVO8_ON) output_low(SERVO8); Ticks4NextInterrupt = TicksTotal - Ticks4Window + Servo_PWM[Servo_Idx]; set_timer1(Ticks4NextInterrupt); if(++Servo_Idx>7) Servo_Idx=0; } ++flag_Phase; } int8 i=0, _n=0, k=0; //Indice para la matriz de programa y _n para la cantidad de lineas signed long programa[lineas_programa][7]; //20 lineas de programa maximo y 7 bytes para cada instruccion (uno para cada punto x y z, angulo, apertura de pinza y uno para la velocidad minima) // o 20 lineas con 7 bytes para cada una de sus articulaciones signed long q[lineas_programa][6]; //q lo va a generar el control cinematico inverso; o directamente la cinematica directa //q no puede ser negativo hay se guardan los angulos aunue si se cambia causa error //al calcular los coeficientes a,b,c,d float qd[lineas_programa][4]; //qd almacena las velocidades de paso para las primeras 4 articulaciones unsigned long _q1, _q2, _q3, _q4, _q5, _q6; //no pueden ser negativos ///////////////////////////////////////////////////////////////////////////// // // Se incluyen las librerias propias de CCS.. // ///////////////////////////////////////////////////////////////////////////// #include <pic18_usb.h> //Capa Microchip PIC18Fxx5x Hardware para el driver USB de los pics #include <PicUSB.h> //Configuración del USB y los descriptores para este dispositivo #include <usb.c> //handles usb setup tokens and get descriptor reports #include <pic_brazo_control.h> //Definicion de la cinematica del manipulador #define menu01 recibe[0] //definimos nombres para manejar mejor el arreglo de recibo #define menu02 recibe[1] #define servo01_1 recibe[2] #define servo01_2 recibe[3] #define servo02_1 recibe[4] #define servo02_2 recibe[5] #define servo03_1 recibe[6] #define servo03_2 recibe[7] #define servo04_1 recibe[8] #define servo04_2 recibe[9] #define servo05_1 recibe[10] #define servo05_2 recibe[11] #define servo06_1 recibe[12] #define servo06_2 recibe[13] #define velocidad01 recibe[14] #define velocidad02 recibe[15] #define velocidad03 recibe[16] #define velocidad04 recibe[17] #define velocidad05 recibe[18] #define velocidad06 recibe[19] #define resultado01 envia[0] //definimos nombre para manejar mejor el envio

#define resultado02 envia[1] #define sensor01_1 envia[2] #define sensor01_2 envia[3] #define sensor02_1 envia[4] #define sensor02_2 envia[5] #define sensor03_1 envia[6] #define sensor03_2 envia[7] #define sensor04_1 envia[8] #define sensor04_2 envia[9] void reset() { Servo_PWM[0] = Ticks4Servo01; Servo_PWM[1] = Ticks4Servo02; Servo_PWM[2] = Ticks4Servo03; Servo_PWM[3] = Ticks4Servo04; Servo_PWM[4] = Ticks4Servo05; Servo_PWM[5] = Ticks4Servo06; delay_ms(200); } void punto_reset(int p) { programa[p][0] = 135; //punto q1 programa[p][1] = 157; //punto q2 programa[p][2] = 202; //punto q3 programa[p][3] = 157; //punto q4 programa[p][4] = 119; //punto q5 programa[p][5] = 97; //punto q6 programa[p][6] = 3; //delay } void main(void) { long vref_value; //lee valor analógico int parte_baja; //para separar el byte bajo después de leer valor analógico int parte_alta; //para separar el byte alto después de leer valor analógico int ADC_ACQT_2TAD=0x1; int8 recibe[20]; //declaramos variables int8 envia[10]; disable_interrupts(global); //setup_adc_ports(NO_ANALOGS); //setup_adc(ADC_OFF); setup_counters(RTCC_INTERNAL,RTCC_DIV_2); setup_timer_0(RTCC_OFF); setup_timer_1(T1_INTERNAL | T1_DIV_BY_1); setup_timer_2(T2_DISABLED,0,1); setup_timer_3(T3_DISABLED); port_b_pullups(FALSE); setup_adc_ports(AN0_TO_AN8 || VSS_VDD); setup_adc(ADC_CLOCK_DIV_64 || ADC_ACQT_2TAD ); set_tris_a(0b11110100); //AN0_TO_AN4 set_tris_e(0b11100000); //AN5_TO_AN7 set_tris_b(0b00000000); set_tris_c(0b00000000); set_tris_d(0b00000000); output_low(SERVO1); output_low(SERVO2); output_low(SERVO3); output_low(SERVO4); output_low(SERVO5); output_low(SERVO6);

output_low(SERVO7); output_low(SERVO8); set_timer1(Ticks4NextInterrupt); enable_interrupts(int_timer1); enable_interrupts(global); usb_init(); //inicializamos el USB usb_task(); //habilita periférico usb e interrupciones //hay que colocar en comentario esta línea si se desea simular con MPLAB usb_wait_for_enumeration(); //esperamos hasta que el PicUSB sea configurado por el host while (TRUE) { if(usb_enumerated()) //si el PicUSB está configurado { if (usb_kbhit(1)) //si el endpoint de salida contiene datos del host { usb_get_packet(1, recibe, 20); //cogemos el paquete de tamaño 20 bytes del EP1 y almacenamos en recibe //usb_get_packet(endpoint, *ptr, max) //el argumento 1: endpoint: es el buffer de datos de entrada, donde llega el paquete de datos. //el argumento 2 *prt: es el apuntador adonde guardaremos ese dato. //el argumento 3 max: es el tamaño de paquete en bytes. if (menu01 == 1) // Modo Prueba { //Aqui se carga el vector de pulsos de los servos Servo_PWM[0]=make16(servo01_2,servo01_1); //Base Servo_PWM[1]=make16(servo02_2,servo02_1); //Hombro Servo_PWM[2]=make16(servo03_2,servo03_1); //Codo Servo_PWM[3]=make16(servo04_2,servo04_1); //muneca Servo_PWM[4]=make16(servo05_2,servo05_1); //muneca Servo_PWM[5]=make16(servo06_2,servo06_1); //dedos } if (menu01 == 2) // Modo Reset { reset(); } if (menu01 == 3) // Inicio de Grabación { //colocamos el índice de la matriz de programa en 1 y colocamos el primer //punto de la interpolación a 0 punto_reset(0); i=1; _n=1; } if (menu01 == 4) // Finaliza la Grabación { //La cantidad es igual al indice punto_reset(i); i++; _n=i; } if (menu01 == 5) // Se inicia el programa guardado // si es 5.1 cinemática inversa si es 5.2 cinemática directa { if (menu02 == 1) //cinemática inversa { for(k=0;k<_n;k++) { cinematica_inversa(programa[k][0],programa[k][1],programa[k][2],programa[k][3],programa[k][4],k); //X Y Z Angulo Apertura } } if (menu02 == 2) //cinemática directa

{ for(k=0;k<_n;k++) { cinematica_directa(programa[k][0],programa[k][1],programa[k][2],programa[k][3],programa[k][4],programa[k][5],k); //q1 q2 q3 q4 q5 q6 } } interpolacion_cubica(_n,menu02); reset(); } if (menu01 == 6) // Se finaliza el programa guardado { reset(); } if (menu01 == 8) // Modo Punto { //guardamos el paso del programa if(i<lineas_programa) { if (menu02 == 1) // Modo Punto XYZ { programa[i][0] = make16(servo02_1,servo01_2); //punto X if(servo01_1) programa[i][0] = programa[i][0] * -1; programa[i][1] = make16(servo03_2,servo03_1); //punto Y if(servo02_2) programa[i][1] = programa[i][1] * -1; programa[i][2] = make16(servo05_1,servo04_2); //punto Z //No puede ser negativo if(servo04_1) programa[i][2] = programa[i][2] * -1; programa[i][3] = make16(servo06_2,servo06_1); //angulo, normalmente en 0 if(servo05_2) programa[i][3] = programa[i][3] * -1; programa[i][4] = make16(0,velocidad01); //Apertura pinza, de 0 a 100 programa[i][5] = make16(0,velocidad02); //velocidad, de 0 a 100 programa[i][6] = make16(0,velocidad03); //delay } if (menu02 == 2) // Modo Punto ANG { programa[i][0] = make16(servo01_2,servo01_1); //punto q1 programa[i][1] = make16(servo02_2,servo02_1); //punto q2 programa[i][2] = make16(servo03_2,servo03_1); //punto q3 programa[i][3] = make16(servo04_2,servo04_1); //punto q4 programa[i][4] = make16(servo05_2,servo05_1); //punto q5 programa[i][5] = make16(servo06_2,servo06_1); //punto q6 programa[i][6] = make16(0,velocidad01); //delay } i++; } } if (menu01 == 9) // Modo Prueba cinemática { programa[0][0] = make16(servo02_1,servo01_2); //punto X if(servo01_1) programa[i][0] = programa[i][0] * -1; programa[0][1] = make16(servo03_2,servo03_1); //punto Y if(servo02_2) programa[i][1] = programa[i][1] * -1; programa[0][2] = make16(servo05_1,servo04_2); //punto Z //No puede ser negativo if(servo04_1) programa[i][2] = programa[i][2] * -1;

programa[0][3] = make16(servo06_2,servo06_1); //ángulo, normalmente en 0 if(servo05_2) programa[i][3] = programa[i][3] * -1; programa[0][4] = make16(0,velocidad01); //Apertura pinza, de 0 a 100 programa[0][5] = make16(0,velocidad02); //velocidad, de 0 a 100 } } }// } }

Fichero pic_brazo_robot.h

#include<math.h> //Basado en los parámetros de Denavit-Hartenberg se generan las //siguientes constantes #define ALTURA_BASE 70.00 //Altura de la Base #define BRAZO 198.00 //Hombro-a-Codo #define ANTEBRAZO 244.00 //Codo-a-Muñeca #define MUNECA 98.00 //Muñeca - incluyendo la extensión del ultimo engranaje #define ftl(x) ((x)>=0?(long)((x)+0.5):(long)((x)-0.5)) //conversión de float a long /*Variables pre calculadas */ float brazo_sq = BRAZO*BRAZO; float antebrazo_sq = ANTEBRAZO*ANTEBRAZO; float radianes(float grados) { return (grados*(pi/180)); } float grados(float radianes) { return (radianes*(180/pi)); } int signo(float s) { if(s>0) return 1; if(s==0) return 0; else return -1; } void posicion_servos(int16 q1, int16 q2, int16 q3, int16 q4, int16 q5, int16 q6) { //Base if(q1 > Ticks4Servo01_sup) q1 = Ticks4Servo01_sup; if(q1 < Ticks4Servo01_inf) q1 = Ticks4Servo01_inf; Servo_PWM[0] = q1; //Hombro if(q2 > Ticks4Servo02_sup) q2 = Ticks4Servo02_sup; if(q2 < Ticks4Servo02_inf)

q2 = Ticks4Servo02_inf; Servo_PWM[1] = q2; //Codo if(q3 > Ticks4Servo03_sup) q3 = Ticks4Servo03_sup; if(q3 < Ticks4Servo03_inf) q3 = Ticks4Servo03_inf; Servo_PWM[2] = q3; //muneca if(q4 > Ticks4Servo04_sup) q4 = Ticks4Servo04_sup; if(q4 < Ticks4Servo04_inf) q4 = Ticks4Servo04_inf; Servo_PWM[3] = q4; //muneca if(q5 > Ticks4Servo05_sup) q5 = Ticks4Servo05_sup; if(q5 < Ticks4Servo05_inf) q5 = Ticks4Servo05_inf; Servo_PWM[4] = q5; //dedos if(q6 > Ticks4Servo06_sup) q6 = Ticks4Servo06_sup; if(q6 < Ticks4Servo06_inf) q6 = Ticks4Servo06_inf; Servo_PWM[5] = q6; } void cinematica_directa(signed long q1, signed long q2, signed long q3, signed long q4, signed long q5, signed long q6, int paso) { q[paso][0] = q1; q[paso][1] = q2; q[paso][2] = q3; q[paso][3] = q4; q[paso][4] = q5; q[paso][5] = q6; } /* rutina para el posicionamiento utilizando la cinemática inversa */ /* (z) es altura, por la tanto no puede ser negativa, (y) es la distancia desde el centro de la base */ void cinematica_inversa(float x, float y, float z, float angulo_muneca_d, int apert_pinza, int paso) { float angulo_muneca_r; float base_angulo_r; float angulo_mano_d; float rdist; float muneca_dist_z; float muneca_dist_y; float muneca_z; float muneca_y; float s_w; float s_w_sqrt; float a1; float a2; float angulo_hombro_r; float angulo_hombro_d; float angulo_codo_r; float angulo_codo_d; float angulo_codo_dn; float q1; float q2; float q3; float q4;

angulo_muneca_r = radianes( angulo_muneca_d ); //angulo en radianes para los calculos //formula 28 del documento hallamos q1 (ángulo base) base_angulo_r = atan2( x, y ); //formula 29 del documento hallamos (distancia desde x,y) rdist = sqrt(( x * x ) + ( y * y )); /* rdist es la coordenada y para el manipulador */ y = rdist; muneca_dist_z = ( sin( angulo_muneca_r )) * MUNECA; muneca_dist_y = ( cos( angulo_muneca_r )) * MUNECA; /* Se calcula la posicion de la muneca */ muneca_z = ( z - muneca_dist_z ) - ALTURA_BASE; muneca_y = y - muneca_dist_y; s_w = ( muneca_z * muneca_z ) + ( muneca_y * muneca_y ); s_w_sqrt = sqrt( s_w ); //formula 30 del documento a1 = atan2( muneca_z, muneca_y ); //formula 31 del documento a2 = acos((( brazo_sq - antebrazo_sq ) + s_w ) / ( 2 * BRAZO * s_w_sqrt )); //formula 32 del documento angulo_hombro_r = a1 + a2; angulo_hombro_d = grados( angulo_hombro_r ); /* angulo del hombro */ //formula 33 del documento angulo_codo_r = acos(( brazo_sq + antebrazo_sq - s_w ) / ( 2 * BRAZO * ANTEBRAZO )); angulo_codo_d = grados( angulo_codo_r ); angulo_codo_dn = -( 180.0 - angulo_codo_d ); /* angulo de la muneca */ //formula 44 del documento angulo_mano_d = ( angulo_muneca_d - angulo_codo_dn ) - angulo_hombro_d; q1 = grados( base_angulo_r ); //validado q2 = angulo_hombro_d - 90.0; //por validar q3 = angulo_codo_d - 90.0; //validado q4 = angulo_mano_d; q[paso][0] = ftl(q1); q[paso][1] = ftl(q2); q[paso][2] = ftl(q3); q[paso][3] = ftl(q4); } //modo 1:cinematica inversa 2:c inematica directa void interpolacion_cubica(int8 n, int8 modo) { //los puntos estan en la matriz programa int8 npuntos = 10; //numeros de puntos a generar por intervalo int8 i_aux,s; float _i; float a[4],b[4],c[4],d[4]; //aqui se almacenan los coeficientes para los 4 servos float qt[4]; //una vez este lleno esste vector se porcede a establecer las senales de los servos float t_aux, c1_aux, c2_aux, d1_aux, d2_aux; int16 d0_aux; int8 T = 1; int16 aux; int8 condicion_01, condicion_02; signed int16 condicion_03, condicion_04; //se obbtienen los coeficientes de los splines cubicos //[ti,tf,a,b,c,d] para cada intervalo

//se usa t continuo en 1 para cada paso //for para los primeros 4 servos for(s=0;s<4;s++) { qd[0][s] = 0; //el primero es cero qd[n-1][s] = 0; //el ultimo es cero for(i_aux=1;i_aux<n-1;i_aux++) { condicion_01 = signo(q[i_aux][s]-q[i_aux -1][s]); condicion_02 = signo(q[i_aux+1][s]-q[i_aux][s]); if(((condicion_01)==(condicion_02))||(q[i_aux][s]==q[i_aux+1][s])||(q[i_aux-1][s]==q[i_aux][s])) { condicion_03 = q[i_aux+1][s]-q[i_aux][s]; condicion_04 = q[i_aux][s]-q[i_aux -1][s]; //ejecutamos la formula por partes //qd[i_aux][s] = 0.5 * ( ((condicion_03)/((i_aux+1)-i_aux)) + ((condicion_04)/(i_aux -(i_aux -1)))); c1_aux = (condicion_03)/((i_aux+1)-i_aux); c2_aux = (condicion_04)/(i_aux -(i_aux-1)); t_aux = c1_aux + c2_aux; qd[i_aux][s] = 0.5 * t_aux; } else qd[i_aux][s] = 0; } } //hasta aquí se tiene //q[][servo] q tiene los ángulos para cada línea de instrucción //qd[][servo] qd define las velocidades de paso las cuales se calcularon a partir de la ecuación 6.6 pag.290 //(Fundamentos de Robótica) //se debe obtener ahora los coeficientes A, B, C y D para el polinomio cubico según pag.300 (Robots y Sistemas Sensoriales) //por lo que se va a obtener A,B,C,D del primer servo para la primera instruccion T = 1; for(i_aux=0;i_aux<n-1;i_aux++)//la posicion tambien da el tiempo { for(s=0;s<4;s++) { a[s] = q[i_aux][s]; b[s] = qd[i_aux][s]; c1_aux = (3/T*T*(q[i_aux+1][s]-q[i_aux][s])); c2_aux = ((1/T) *(qd[i_aux+1][s]+(2*qd[i_aux][s]))); //c[s] = (3/T*T*(q[i_aux+1][s]-q[i_aux][s])) - ((1/T) *(qd[i_aux+1][s]+(2*qd[i_aux][s]))); c[s] = c1_aux - c2_aux; d0_aux = q[i_aux+1][s]-q[i_aux][s]; //6 0 //d1_aux = (-2/(T*T*T))*(d0_aux); d1_aux = (2*d0_aux)*-1; d2_aux = (1/(T*T))*(qd[i_aux+1][s]+qd[i_aux][s]); //d[s] = (-2/(T*T*T))*(q[i_aux+1][s]-q[i_aux][s]) + (1/(T*T))*(qd[i_aux+1][s]+qd[i_aux][s]); d[s] = d1_aux + d2_aux; } //ya tenemos los coeficientes para cada servo (qt(t)) //ahora cuadramos las senales con mas resolucion en tiempo en este caso 10 puntos entre tramo //aqui se envia el punto y luego la interpolación //tomamos prestada la variable c1_aux para no crear otra nueva if(modo == 1) //aplicamos la interpolacion basado en lo calculado con la cinematica inversa { aux = q[i_aux][0] * ra; _q1 = Ticks4Servo01_medio - aux; aux = q[i_aux][1] * ra; _q2 = Ticks4Servo02_medio + aux; aux = q[i_aux][2] * ra; _q3 = Ticks4Servo03_medio - aux;

aux = q[i_aux][3] * ra; _q4 = Ticks4Servo04_medio + aux; _q5 = Ticks4Servo05_medio; _q6 = Ticks4Servo06_medio; } if(modo == 2) //cinemática directa { _q1 = (unsigned long)q[i_aux][0]; _q2 = (unsigned long)q[i_aux][1]; _q3 = (unsigned long)q[i_aux][2]; _q4 = (unsigned long)q[i_aux][3]; _q5 = (unsigned long)q[i_aux][4]; _q6 = (unsigned long)q[i_aux][5]; } //posicion_servos(_q1,_q2,_q3,_q4,_q5,_q6); //delay_ms(100); for(_i=0.0;_i<1;_i=_i+0.01) { qt[0]=a[0]+b[0]*(_i)+c[0]*(_i)*(_i)+d[0]*(_i)*(_i)*(_i); qt[1]=a[1]+b[1]*(_i)+c[1]*(_i)*(_i)+d[1]*(_i)*(_i)*(_i); qt[2]=a[2]+b[2]*(_i)+c[2]*(_i)*(_i)+d[2]*(_i)*(_i)*(_i); qt[3]=a[3]+b[3]*(_i)+c[3]*(_i)*(_i)+d[3]*(_i)*(_i)*(_i); if(modo == 1) //aplicamos la interpolación basado en lo calculado con la cinemática inversa { //enviamos la senal a los servos aux = qt[0] * ra; _q1 = Ticks4Servo01_medio - aux; aux = qt[1] * ra; _q2 = Ticks4Servo02_medio + aux; aux = qt[2] * ra; _q3 = Ticks4Servo03_medio - aux; aux = qt[3] * ra; _q4 = Ticks4Servo04_medio + aux; _q5 = Ticks4Servo05_medio; _q6 = Ticks4Servo06_medio; } if(modo == 2) //cinemática directa { _q1 = ftl(qt[0]*ra); _q2 = ftl(qt[1]*ra); _q3 = ftl(qt[2]*ra); _q4 = ftl(qt[3]*ra); _q5 = q[i_aux][4]*ra; _q6 = q[i_aux][5]*ra; } posicion_servos(_q1,_q2,_q3,_q4,_q5,_q6); //sin este delay el robot no se mueve ya que los cálculos se realizan muy rápido //delay_us no funciona delay_ms(programa[i_aux][6]); //delay_ms(3); } } }

ANEXOS F

Código del Sistema de Programación del Robot

Fichero frm_configura_movimiento.cs

using System; using System.IO; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.Threading; using System.Runtime.InteropServices; using System.Xml; using lib; namespace RiCOS //Robotic Interface Configuration Software { public partial class frm_configura_movimiento : Form { //static pieza_robot base_robot; PicUSBAPI _PicUSBAPI = new PicUSBAPI(); byte[] buf = new Byte[2]; uint[] ini_pos = new uint[6]; uint[] min_pos = new uint[6]; uint[] max_pos = new uint[6]; uint[] habilitado = new uint[6]; uint[] actual_pos = new uint[6]; public frm_configura_movimiento() { InitializeComponent(); } private bool isDirty = new bool(); private bool isLoaded = new bool(); private string Filename = string.Empty; private void frm_configura_movimiento_Load(object sender, EventArgs e) { int i = 0; XmlDocument conf_actuadores = new XmlDocument(); conf_actuadores.Load("conf_actuadores.xml"); XmlNode nodo_actuador = conf_actuadores.DocumentElement; foreach (XmlNode nodo_hijo in nodo_actuador.ChildNodes) { foreach (XmlNode nodo in nodo_hijo.ChildNodes) { if (nodo.Name == "habilitado") habilitado[i] = uint.Parse(nodo.InnerText.ToString()); if (nodo.Name == "max_pos") max_pos[i] = uint.Parse(nodo.InnerText.ToString()); if (nodo.Name == "min_pos") min_pos[i] = uint.Parse(nodo.InnerText.ToString()); if (nodo.Name == "ini_pos") { ini_pos[i] = uint.Parse(nodo.InnerText.ToString()); actual_pos[i] = uint.Parse(nodo.InnerText.ToString()); }

} i++; } } private void btn_cancelar_Click(object sender, EventArgs e) { this.Close(); } private void btn_guardar_Click(object sender, EventArgs e) { this.openFileDialog.DefaultExt = "*.rps"; this.openFileDialog.Filter = "Archivos RPS|*.rps"; if (this.openFileDialog.ShowDialog() == DialogResult.OK) { this.rtbText.LoadFile(this.openFileDialog.FileName, RichTextBoxStreamType.PlainText); this.tbPath.Text = this.openFileDialog.FileName; this.Filename = this.openFileDialog.SafeFileName; this.isLoaded = true; } } private void copiarToolStripMenuItem_Click(object sender, EventArgs e) { this.rtbText.Copy(); } private void pegarToolStripMenuItem_Click(object sender, EventArgs e) { this.rtbText.Paste(); } private void cortarToolStripMenuItem_Click(object sender, EventArgs e) { this.rtbText.Cut(); } private void menu_Opening(object sender, CancelEventArgs e) { if (string.IsNullOrEmpty(this.rtbText.SelectedText)) { this.menu.Items[0].Enabled = false; this.menu.Items[1].Enabled = false; } else { this.menu.Items[0].Enabled = true; this.menu.Items[1].Enabled = true; } } private void rtbText_TextChanged(object sender, EventArgs e) { this.isDirty = true; } public void guardar() { SaveFileDialog saveFile = new SaveFileDialog(); saveFile.DefaultExt = "*.rps"; saveFile.Filter = "Archivos RPS|*.rps"; if (saveFile.ShowDialog() == System.Windows.Forms.DialogResult.OK && saveFile.FileName.Length > 0) {

rtbText.SaveFile(saveFile.FileName, RichTextBoxStreamType.PlainText); MessageBox.Show("Se guardo exitosamente " + System.IO.Path.GetFileName(saveFile.FileName), "Aviso"); } this.tbPath.Text = saveFile.FileName; this.Filename = System.IO.Path.GetFileName(saveFile.FileName); this.isLoaded = true; this.isDirty = false; } private void limpiar() { tbPath.Text = string.Empty; rtbText.Text = string.Empty; this.isDirty = false; this.isLoaded = false; this.Filename = string.Empty; } private void btn_nuevo_Click(object sender, EventArgs e) { DialogResult result = DialogResult.Cancel; if (isLoaded) { if (isDirty) { if ((result = MessageBox.Show("¿Desea guardar los cambios realizados a " + Filename + "?", "Aviso", MessageBoxButtons.YesNoCancel)) == DialogResult.Yes) { rtbText.SaveFile(tbPath.Text, RichTextBoxStreamType.PlainText); MessageBox.Show("Se guardo exitosamente " + System.IO.Path.GetFileName(tbPath.Text), "Aviso"); limpiar(); } else if (result == DialogResult.No) limpiar(); else return; } else limpiar(); } else { if (isDirty) { if ((result = MessageBox.Show("¿Desea guardar los cambios realizados al programa sin nombre?", "Aviso", MessageBoxButtons.YesNoCancel)) == DialogResult.Yes) { guardar(); limpiar(); } else if (result == DialogResult.No) limpiar(); else return; } else limpiar(); } } private void btn_guardar_programa_Click(object sender, EventArgs e) { DialogResult result = DialogResult.Cancel;

if (isLoaded) { if (isDirty) { rtbText.SaveFile(tbPath.Text, RichTextBoxStreamType.PlainText); MessageBox.Show("Se guardo exitosamente " + System.IO.Path.GetFileName(tbPath.Text), "Aviso"); } } else { if (isDirty) { if ((result = MessageBox.Show("¿Desea guardar los cambios realizados al programa sin nombre?", "Aviso", MessageBoxButtons.YesNoCancel)) == DialogResult.Yes) { guardar(); } else return; } else return; } } private void btn_play_Click(object sender, EventArgs e) { //Se toma cada instruccion y se transforma a la forma que entiende el micro //se recorre cada linea foreach (String linea in rtbText.Lines) { if (linea.StartsWith("origen")) _PicUSBAPI.Envia_Comando(2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); else if (linea.StartsWith("ini_grabar")) _PicUSBAPI.Envia_Comando(3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); else if (linea.StartsWith("fin_grabar")) _PicUSBAPI.Envia_Comando(4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); else if (linea.StartsWith("ini_trabajo")) //se dejo fijo para cinematica directa _PicUSBAPI.Envia_Comando(5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); else if (linea.StartsWith("fin_trabajo")) _PicUSBAPI.Envia_Comando(6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); else if (linea.StartsWith("limites_sup")) { byte[] max_pos_servo01 = new Byte[2]; byte[] max_pos_servo02 = new Byte[2]; byte[] max_pos_servo03 = new Byte[2]; byte[] max_pos_servo04 = new Byte[2]; byte[] max_pos_servo05 = new Byte[2]; byte[] max_pos_servo06 = new Byte[2]; max_pos_servo01 = System.BitConverter.GetBytes(max_pos[0] * Program._ra); max_pos_servo02 = System.BitConverter.GetBytes(max_pos[1] * Program._ra); max_pos_servo03 = System.BitConverter.GetBytes(max_pos[2] * Program._ra); max_pos_servo04 = System.BitConverter.GetBytes(max_pos[3] * Program._ra); max_pos_servo05 = System.BitConverter.GetBytes(max_pos[4] * Program._ra); max_pos_servo06 = System.BitConverter.GetBytes(max_pos[5] * Program._ra); _PicUSBAPI.Envia_Comando_Configuracion(7, 1, uint.Parse(max_pos_servo01[0].ToString()), uint.Parse(max_pos_servo01[1].ToString()), uint.Parse(max_pos_servo02[0].ToString()), uint.Parse(max_pos_servo02[1].ToString()), uint.Parse(max_pos_servo03[0].ToString()), uint.Parse(max_pos_servo03[1].ToString()), uint.Parse(max_pos_servo04[0].ToString()), uint.Parse(max_pos_servo04[1].ToString()), uint.Parse(max_pos_servo05[0].ToString()), uint.Parse(max_pos_servo05[1].ToString()), uint.Parse(max_pos_servo06[0].ToString()), uint.Parse(max_pos_servo06[1].ToString()), 0, 0, 0, 0, 0, 0); }

else if (linea.StartsWith("limites_inf")) { byte[] min_pos_servo01 = new Byte[2]; byte[] min_pos_servo02 = new Byte[2]; byte[] min_pos_servo03 = new Byte[2]; byte[] min_pos_servo04 = new Byte[2]; byte[] min_pos_servo05 = new Byte[2]; byte[] min_pos_servo06 = new Byte[2]; min_pos_servo01 = System.BitConverter.GetBytes(min_pos[0] * Program._ra); min_pos_servo02 = System.BitConverter.GetBytes(min_pos[1] * Program._ra); min_pos_servo03 = System.BitConverter.GetBytes(min_pos[2] * Program._ra); min_pos_servo04 = System.BitConverter.GetBytes(min_pos[3] * Program._ra); min_pos_servo05 = System.BitConverter.GetBytes(min_pos[4] * Program._ra); min_pos_servo06 = System.BitConverter.GetBytes(min_pos[5] * Program._ra); _PicUSBAPI.Envia_Comando_Configuracion(7, 1, uint.Parse(min_pos_servo01[0].ToString()), uint.Parse(min_pos_servo01[1].ToString()), uint.Parse(min_pos_servo02[0].ToString()), uint.Parse(min_pos_servo02[1].ToString()), uint.Parse(min_pos_servo03[0].ToString()), uint.Parse(min_pos_servo03[1].ToString()), uint.Parse(min_pos_servo04[0].ToString()), uint.Parse(min_pos_servo04[1].ToString()), uint.Parse(min_pos_servo05[0].ToString()), uint.Parse(min_pos_servo05[1].ToString()), uint.Parse(min_pos_servo06[0].ToString()), uint.Parse(min_pos_servo06[1].ToString()), 0, 0, 0, 0, 0, 0); } else if (linea.StartsWith("paso_xyz") || linea.StartsWith("prueba")) { //separamos x,y,z - el angulo se implementa en la muneca. //linea.Remove(0, 5); //elimina la palabra //linea.Replace("paso", ""); string[] XYZ = linea.Split(' '); uint x_signo = 0; //positivo uint y_signo = 0; uint z_signo = 0; byte[] buf_x = new Byte[2]; byte[] buf_y = new Byte[2]; byte[] buf_z = new Byte[2]; byte[] grip = new Byte[2]; if (XYZ[1].StartsWith("-")) { x_signo = 1; XYZ[1] = XYZ[1].Replace("-",""); } if (XYZ[2].StartsWith("-")) { y_signo = 1; XYZ[2] = XYZ[2].Replace("-", ""); } if (XYZ[3].StartsWith("-")) { z_signo = 1; XYZ[3] = XYZ[3].Replace("-", ""); } buf_x = System.BitConverter.GetBytes(uint.Parse(XYZ[1].ToString())); buf_y = System.BitConverter.GetBytes(uint.Parse(XYZ[2].ToString())); buf_z = System.BitConverter.GetBytes(uint.Parse(XYZ[3].ToString())); grip = System.BitConverter.GetBytes(uint.Parse(XYZ[4].ToString())); if (linea.StartsWith("paso")) _PicUSBAPI.Envia_Comando(8, 1, x_signo, uint.Parse(buf_x[0].ToString()), uint.Parse(buf_x[1].ToString()), y_signo, uint.Parse(buf_y[0].ToString()), uint.Parse(buf_y[1].ToString()), z_signo, uint.Parse(buf_z[0].ToString()), uint.Parse(buf_z[1].ToString()), 0, uint.Parse(grip[0].ToString()), uint.Parse(grip[1].ToString()), uint.Parse(XYZ[5].ToString()),100, 0, 0, 0, 0); if (linea.StartsWith("prueba")) _PicUSBAPI.Envia_Comando(9, 0, x_signo, uint.Parse(buf_x[0].ToString()), uint.Parse(buf_x[1].ToString()), y_signo, uint.Parse(buf_y[0].ToString()), uint.Parse(buf_y[1].ToString()), z_signo, uint.Parse(buf_z[0].ToString()), uint.Parse(buf_z[1].ToString()), 0, uint.Parse(grip[0].ToString()), uint.Parse(grip[1].ToString()), uint.Parse(XYZ[5].ToString()),100, 0, 0, 0, 0); } else if (linea.StartsWith("parada")) _PicUSBAPI.Envia_Comando(9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); else if (linea.StartsWith("paso_ang")) { string[] ANG = linea.Split(' '); byte[] buf_q1 = new Byte[2]; byte[] buf_q2 = new Byte[2]; byte[] buf_q3 = new Byte[2]; byte[] buf_q4 = new Byte[2];

byte[] buf_q5 = new Byte[2]; byte[] buf_q6 = new Byte[2]; byte[] buf_q7 = new Byte[2]; buf_q1 = System.BitConverter.GetBytes(uint.Parse(ANG[1].ToString())); buf_q2 = System.BitConverter.GetBytes(uint.Parse(ANG[2].ToString())); buf_q3 = System.BitConverter.GetBytes(uint.Parse(ANG[3].ToString())); buf_q4 = System.BitConverter.GetBytes(uint.Parse(ANG[4].ToString())); buf_q5 = System.BitConverter.GetBytes(uint.Parse(ANG[5].ToString())); buf_q6 = System.BitConverter.GetBytes(uint.Parse(ANG[6].ToString())); buf_q7 = System.BitConverter.GetBytes(uint.Parse(ANG[7].ToString())); //delay _PicUSBAPI.Envia_Comando_Configuracion(8, 2, uint.Parse(buf_q1[0].ToString()), uint.Parse(buf_q1[1].ToString()), uint.Parse(buf_q2[0].ToString()), uint.Parse(buf_q2[1].ToString()), uint.Parse(buf_q3[0].ToString()), uint.Parse(buf_q3[1].ToString()), uint.Parse(buf_q4[0].ToString()), uint.Parse(buf_q4[1].ToString()), uint.Parse(buf_q5[0].ToString()), uint.Parse(buf_q5[1].ToString()), uint.Parse(buf_q6[0].ToString()), uint.Parse(buf_q6[1].ToString()), uint.Parse(buf_q7[0].ToString()), uint.Parse(buf_q7[1].ToString()), 0, 0, 0, 0); } else { MessageBox.Show("Error en el programa", "Mensaje"); return; } } } private void btn_parada_Click(object sender, EventArgs e) { _PicUSBAPI.Envia_Comando(9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); } } }

ANEXOS G

Electrónica, Sensores y Estructura del Robot Industrial

Vista Superior de la Tarjeta de Control del Robot Industrial

Vista Inferior de la Tarjeta de Control del Robot Industrial

Detalle de los Sensores del Robot Industrial

Detalle de los Sensores y Codificadores del Robot Industrial en sus Articulaciones

Robot Industrial Ensamblado