El robot CS-113 Service-Arm (brazo de servicio) es un sistema diseñado para simular las operaciones de un robot manipulador industrial. Se trata de un brazo articulado con cinco grados de libertad y una pinza como herramienta terminal. Se encuentra en algunos centros docentes de Educación Secundaria, aunque también se utiliza a nivel Universitario (Universidad de Navarra: www.ayc.unavarra.es/arocena/arocena.htm, Universidad de Lleida: robotica.udl.es/brazo_robot/brazo.htm). Actualmente se encuentra en la red alguna referencia a su comercialización por la empresa Chang-Shing (www.emona.com.au/catalogue/e12.html)
El robot cuenta con una unidad controladora inserta en su cuerpo inferior, basada en un microprocesador Z80. Las articulaciones y la pinza se mueven gracias a 6 motores paso a paso de 12 V. El control programado se lleva a cabo mediante el puerto paralelo. Un cable plano que surge de la placa inferior y termina en un conector DB25 macho se une directamente al conector DB25 hembra del PC. Presenta dos modos de funcionamiento en modo test.
Sus especificaciones técnicas se resumen en la tabla siguiente.
|
CS-113 Service-Arm |
||
|
Grados de libertad |
5 |
|
| Precisión del posicionado |
+/- 0.9 mm |
|
| Carga útil máx. | 0.5 kg | |
| Integrados | micro Z80A, memoria ROM, memoria RAM | |
| Interface | Puerto paralelo | |
| Control de velocidad | Por onda cuadrada | |
| Peso | 8 kg | |
| Pinza |
Accionada por motor paso a paso Intervalo: +/- 1800 pasos Paso: 0.1º Apertura: 45 mm |
Esquema del robot CS-113 en posición inicial o de referencia (home)
Este robot posee un juego básico de instrucciones para su operación, residentes en una EPROM, que se recogen en la tabla siguiente:
| Orden | Argumentos | Intervalo | Nombre | Descripción |
Z |
ZERO | Establecer la posición actual como referencia | ||
N |
HOME, NEST | Volver a la posición de referencia | ||
C |
GRIP CLOSE | Cerrar totalmente la pinza | ||
O |
GRIP OPEN | Abrir totalmente la pinza | ||
H |
n |
1-100 |
HERE | Memorizar la posición actual en el n-ésimo lugar de la RAM |
G |
n |
1-100 |
GOTO | Posicionar en las coordenadas memorizadas en el n-ésimo lugar de la RAM |
S |
n |
1-5 |
SPEED | Fijar la velocidad de giro de los motores: 1 - lenta 5 - rápida |
D |
n |
1-9 |
DELAY | Detener el movimiento unos segundos |
L |
n |
0-1 |
LIMIT | Activar la protección de vigilancia de
límites de los motores: 1 - activar 0 - desactivar Si está activada y un motor sobrepasa los límites establecidos, se enciende el piloto rojo de error y sólo se puede recuperar con el botón reset o con la instrucción N. |
M |
p1,p2,p3,p4,p5,p6 |
p1>0: giro + cintura p1<0: giro - cintura p2>0: subir hombro p2<0: bajar hombro p3>0: subir codo p3<0: bajar codo p4>0,p5>0: giro - muñeca p4<0,p5<0: giro + muñeca p4<0,p5>0: elevar muñeca p4>0,p5<0: bajar muñeca p6>0: abrir pinza p6<0: cerrar pinza |
MOVE | Mover a la posición de cada motor especificada (en pasos); ver el intervalo permitido de pasos de cada motor en la tabla superior). |
P |
n,p1,p2,p3,p4,p5,p6 |
n: 1-100 |
POSITION | Memorizar una posición relativa a la de referencia (en pasos) en el lugar n-ésimo de la RAM. |
|
(*) Al enviar las instrucciones al puerto paralelo se debe añadir un "retorno de carro" al final (código ascii hexadecimal 0D o decimal 13) |
||||
Ejemplos:
N:
va a la posición de referencia.
S5:
establece la mayor velocidad de los motores.
M0,-400,0,600,-600,-1490: baja
hombro, baja muñeca y abre pinza.
 |
Funcionamiento en modo test: |
Primer modo de
test: éste debe efectuarse con el robot sin carga (desconectado
del puerto). Su propósito es garantizar la posibilidad de movimiento de
todas las uniones. También puede emplearse para situar al robot en la
posición de referencia como paso previo a cualquier acción exterior de
control de la máquina.
La posición inicial o de referencia (home) corresponde a aquélla en que
la pareja de flechas indicadoras de cada articulación se halla alineada (Þ Ü). En esta posición el nº de pasos de cada motor es 0 (posición ZERO).
El método a seguir es el siguiente :
Pulsar el botón reset y medio segundo después el de test.
Mantener ambos botones pulsados y soltar el botón reset.
Continuar pulsando el botón test durante unos 3 segundos y soltarlo.
En el caso en que la pinza del robot estuviera cerrada (si no es así la cerrará) el robot realizará una acción cada vez que se pulse el botón test. El movimiento correspondiente no cesará mientras se tenga el botón pulsado. La secuencia de movimientos que se irá desarrollando a medida que se vaya accionando el pulsador de test será la siguiente:
M1 (cintura) ® giro negativo M1 (cintura) ® giro positivo M2 (hombro) ® elevación M2 (hombro) ® descenso M3 (codo) ® descenso M3 (codo) ® elevación M4,M5 (muñeca) ® giro negativo M4,M5 (muñeca) ® giro positivo M4,M5 (muñeca) ® descenso M4,M5 (muñeca) ® elevación M6 (pinza) ® apertura M6 (pinza) ® cierreA la siguiente pulsación de la tecla test se repite el proceso accionándose el motor M1. Al realizar este, se debe procurar NO sobrepasar los límites de movimiento de los motores, para no causar trastornos en los motores del robot.
Segundo modo de test: los
movimientos realizados en esta segunda prueba de verificación están
programados en la ROM del CS-113. Este test está pensado para probar la
sincronización de los movimientos de los distintos motores, la
repetitividad de los mismos y los ángulos.
Para su realización, obsérvese el siguiente método de operación :
Alinear adecuadamente el robot (utilizando el test 1) dejándolo en posición ZERO. Pulsar el botón reset para abandonar el primer modo de test. Es importante asegurarse de que el robot quede lo más exactamente posible en posición ZERO antes de empezar este nuevo test.
Pulsar y mantener apretado el botón reset en primer lugar y seguidamente el de test, sin soltar el de reset. Soltar el pulsador de reset y mantener pulsado el de test durante unos 5 segundos.
Al cabo de este tiempo el robot empieza a realizar una serie de movimientos sincronizados bajo el control de su propio programa en ROM. En este instante debe soltarse el botón de test.
La velocidad de los movimientos varía entre los 5 posibles niveles siguiendo una secuencia 1-3-5 de forma indefinida.
Para finalizar este procedimiento de test, debe mantenerse pulsado el botón de test durante un segundo. El robot se detendrá en la posición ZERO después de completar el ciclo a velocidad 5. Pulsar el botón de reset para recuperar el control de la máquina.
El control del robot se puede llevar a cabo en cualquier lenguaje que permita el acceso al puerto paralelo del PC. Un ejemplo sencillo en lenguaje C (Turbo C) de cómo dialogar con el robot se muestra a continuación:
/*
EJEMPLO DE CONTROL BÁSICO DEL ROBOT CS-113
2002 Víctor R. González
*/
#include <stdio.h>
#include <dos.h>
/* Direcciones del puerto paralelo */
#define LPT_BASE 0x378
#define DATOS LPT_BASE
#define ESTADO LPT_BASE+1
#define CONTROL LPT_BASE+2
void envia_orden (char *orden);
void envia_b (unsigned char caracter);
main() {
envia_orden ("N"); /* Va a la pos. de referencia */
envia_orden ("S5"); /* Pone la velocidad al máximo */
envia_orden ("M0,-400,0,600,-600,-1490"); /*baja hombro,
baja muñeca y abre pinza */
return 0;
}
/* Envía una orden al puerto */
void envia_orden (char* orden)
{
unsigned i = 0;
/* Envía la orden al puerto */
while (orden[i] != '\0') envia_b ( orden[i++] );
envia_b ('\n'); /* Envía un retorno de carro */
}
/* Envía un carácter al puerto mediante un protocolo similar al de
las impresoras
*/
void envia_b (unsigned char caracter)
{
outportb (DATOS, caracter);
/* Espera a que el dispositivo esté libre: BUSY bajo (S7# = 1)*/
while ( ! (inportb(ESTADO) & 0x80) );
/* Solicita aceptación del byte: STB# bajo (C0# = 1) */
outportb (CONTROL, inportb(CONTROL) | 0x01);
/* Espera confirmación de dato recibido: ACK# bajo (S6=0)*/
/* No se utiliza con el robot, simplemente se realiza una espera */
/* while ( inportb(ESTADO) & 0x40 ); */
delay(1);
/* Repone STB# alto (C0# = 0) */
outportb (CONTROL, inportb(CONTROL) & ~0x01);
delay(1); /* Espera entre envíos para no bloquear el robot */
}
|
Un programa en código C bastante más avanzado se encuentra en el archivo fuente CS_113_D.c, del cual sólo se lista a continuación la cabecera debido a su extensión.
/*
CS_113_D.c
CONTROL DEL ROBOT CS-113
2002 Víctor R. González
*/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <dos.h>
#include "paralelo.h"
#define TRUE 1
#define FALSE 0
#define PASO_M1 0.12 /* paso angular de la cintura (motor 1)*/
#define PASO_M2 0.12 /* paso angular del hombro */
#define PASO_M3 0.08 /* paso angular del codo */
#define PASO_M4 0.05 /* paso angular de la muñeca (rotación) */
#define PASO_M5 0.05 /* paso angular de la muñeca (inclinación) */
#define PASO_M6 0.10 /* paso angular de la pinza */
#define LIM_M1 1000 /* +/- límite (en pasos) de la cintura */
#define LIM_M2 600 /* +/- límite (en pasos) del hombro */
#define LIM_M3 600 /* +/- límite (en pasos) del codo */
#define LIM_M4 3600 /* +/- límite (en pasos) de la muñeca (rotación) */
#define LIM_M5 1992 /* +/- límite (en pasos) de la muñeca (inclinación) */
#define LIM_M6 1800 /* +/- límite (en pasos) de la pinza */
#define VELOCIDAD_MIN 1 /* Velocidad mínima */
#define VELOCIDAD_MAX 5 /* Velocidad máxima */
#define VELOCIDAD_INI VELOCIDAD_MAX /* Velocidad inicial */
#define MEM_MIN 1 /* Posiciones de memoria disponibles */
#define MEM_MAX 100
#define MOV_ABSOLUTO 0 /* Movimiento absoluto o relativo */
#define MOV_RELATIVO 1
#define MENU_LIN1 8
#define MENU_COL1 33
#define MENU_COL2 38
#define INTRO 13
#define TAB 9
#define origen orden("Z") /* ZERO: Establece la posición actual como referencia */
#define ir_origen orden("N") /* HOME: Ir a la posici¢n de referencia indicada por ZERO */
#define cierra_mano_todo orden("C") /* GRIP CLOSE: cierra al máximo la pinza */
#define abre_mano_todo orden("O") /* GRIP OPEN: abre al máximo la pinza */
#define para(seg) orden1("D", seg) /* DELAY: detiene el robot <seg> segundos (1-9)*/
#define velocidad(veloc) orden1("S", veloc) /* SPEED: establece la velocidad de los motores (1-5) */
#define limites(no_si) orden1("L", no_si) /* LIMIT: activa la vigilancia de los límites de los motores (0-1) */
#define pos_mem(n_pos) orden1("H", n_pos) /* HERE: memoriza las posiciones de cada motor (1-100)*/
#define ir_mem(n_pos) orden1("G", n_pos) /* GOTO: va a posición memorizada (1-100) */
#define cintura_izqda(grad) orden6("M", -grad, 0, 0, 0, 0, 0)
#define cintura_dcha(grad) orden6("M", +grad, 0, 0, 0, 0, 0)
#define hombro_sube(grad) orden6("M", 0, -grad, 0, 0, 0, 0)
#define hombro_baja(grad) orden6("M", 0, +grad, 0, 0, 0, 0)
#define codo_sube(grad) orden6("M", 0, 0, -grad, 0, 0, 0)
#define codo_baja(grad) orden6("M", 0, 0, +grad, 0, 0, 0)
#define muneca_sube(grad) orden6("M", 0, 0, 0, -grad, +grad, 0)
#define muneca_baja(grad) orden6("M", 0, 0, 0, +grad, -grad, 0)
#define muneca_izqda(grad) orden6("M", 0, 0, 0, -grad, -grad, 0)
#define muneca_dcha(grad) orden6("M", 0, 0, 0, +grad, +grad, 0)
#define cierra_mano(grad) orden6("M", 0, 0, 0, 0, 0, +grad)
#define abre_mano(grad) orden6("M", 0, 0, 0, 0, 0, -grad)
#define motores(cint, hom, cod, mun_ele, mun_gir, mano) orden6("M", cint, hom, cod, mun_ele, mun_gir, mano)
int ParaleloIni (void); /* Inicia el puerto paralelo */
void enviab (unsigned char caracter);
void orden (char* id);
void orden1 (char* id, int arg);
void orden6 (char* id, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6);
void msg_orden(char* orden);
void msg_error(char* mens);
unsigned selector(int* valor, int inf, int sup, float factor, char* form);
void espera_fin_mov(int p1, int p2, int p3, int p4, int p5, int p6,
int velocidad);
void lote ( void);
void main()
{
....................... } |
Cuando se ejecuta, se obtiene una pantalla como la que se
muestra en la imagen adjunta, la cual da idea de las posibilidades de control
que permite el programa. Éste admite, además, la lectura de un archivo de
lotes de instrucciones, denominado CS113.TXT, para programar
distintas trayectorias del robot.
A continuación se muestra la grabación en el aula-taller de
una trayectoria programada seguida por este robot con la finalidad de apilar dos
cilindros en una posición intermedia cuando inicialmente se hallaban situados en
dos posiciones laterales. El archivo de lotes de instrucciones utilizado es el
siguiente (CS113.TXT):
; ; Trayectoria del brazo robot CS-113 para apilar dos cilindros ; en una posición centrada, desde dos posiciones laterales ; L0 ; Límites desactivados. M-500,0,0,0,0,0 ; Gira cintura a la izquierda. M0,-600,0,-150,150,-1490 ; Baja hombro, sube muñeca y abre pinza. M0,0,0,0,0,1350 ; Cierra pinza (sobre cilindro). M0,400,0,0,0,0 ; Sube hombro. M500,-400,0,0,0,0 ; Gira cintura a la derecha, baja hombro. M0,0,0,150,-150,-1350 ; Baja muñeca, abre pinza. D1 ; Espera 1 seg. M0,400,0,0,0,0 ; Sube hombro. M500,0,0,0,0,0 ; Gira cintura a la derecha. M0,-400,0,-150,150,0 ; Baja hombro, sube muñeca M0,0,0,0,0,1350 ; Cierra pinza (sobre cilindro). M-500,400,0,0,0,0 ; Gira cintura a la izquierda, sube hombro. M0,-325,0,0,0,0 ; Baja hombro. M0,0,0,0,0,-1350 ; Abre pinza. N ; Va a posición de referencia. |
Con esta documentación se adjunta demás un programa de control/simulación de los movimientos de este robot, para entornos Windows 9x, todavía en fase de desarrollo, realizado en Visual Basic.
