Está en la página 1de 4

Universidad Nacional de Colombia Automatizacin de Procesos de Manufactura

.


1
MAQUINADO EN TORNO SUIZO TORRE DE AJEDREZ

Miguel Angel Pulido Valencia
miapulidova@unal.edu.co
Juan David Osorio Pacheco
jdosoriop@unal.edu.co



RESUMEN: Este documento contiene la
explicacin del desarrollo e implementacin de un
programa para la solucin de las torres de Hani
en un robot Gantry de forma automtica y
parametrizada.


PALABRAS CLAVE: Gantry,
parametrizacin, estructuracin, algoritmo, rutas
estndar.


1 DESCRIPCIN

Por medio del Robot Gantry ubicado en el
LabFabEx de la universidad nacional de Colombia
se busca realizar el ejercicio de las torres de
Hani, el cual consiste en tres pilas verticales. En
la primera se apila un nmero determinado de
bloques que determinar la complejidad de la
solucin en tamao decreciente, es decir, el
bloque ms grande abajo, no hay dos bloques
iguales; quedando las otras dos pilas vacas. El
juego consiste en pasar todos los bloques de la
pila ocupada (es decir la que posee la torre) a la
ltima pila. Para realizar este objetivo, es
necesario seguir tres simples reglas: Slo se
puede mover un disco cada vez, un bloque de
mayor tamao no puede descansar sobre uno ms
pequeo que l mismo y slo se puede desplazar
el disco que se encuentre arriba en cada pila.


Figura 1. Montaje Inicial Torres de Hani

2 DESARROLLO

2.1 EL ROBOT

El robot Gantry cuenta con un controlador
MX2000, para este ejercicio usaremos los tres ejes
principales del robot X Y y Z, para desplazarnos en
el espacio de trabajo y una salida digital de 24
voltios, para energizar un electroimn.


Figura 2. Robot Gantry


2.2 LOS BLOQUES

Los bloques usados para este ejercicio son
piezas cuadradas de 20mm de grosor con una
platina integrada en cada una de ellas, esto con el
fin de ser sujetadas por el electroimn. Las piezas
se pueden apreciar en la Figura 3.


Figura 3. Bloques

2.3 PROGRAMACIN.

El algoritmo regularmente usado para la
solucin a este ejercicio, se realiza por medio de
Universidad Nacional de Colombia Automatizacin de Procesos de Manufactura
.


2
recursividad, pero en este caso el lenguaje del
controlador no soporta recursividad, es por esto,
que realizamos un anlisis de los pasos para cierto
nmero de piezas, y comparando los resultados,
obtuvimos las siguientes conclusiones:

La rutina para un nmero de piezas n, es una
subrutina de la correspondiente para un
nmero de piezas m, siendo m>n, y m y n
pares o impares ambas.
La rutina para nmeros pares de piezas,
difiere de la rutina de nmeros impares de
piezas nicamente, en un aspecto,
intercambia la torre 2 con la 3

Gracias a este anlisis, decidimos, usar como
estrategia de ruteo, una tabla que contiene los
pasos de la rutina para 6 piezas, y dependiendo el
nmero de piezas a mover, leeramos una parte de
esta tabla.
2.3.1 El nmero de pasos a leer en la tabla, est
regido por la siguiente ecuacin: Pasos= 2n-1

2.3.2 A Analizando la escena se identificaron los
siguientes parmetros
k= altura de la pieza
p=profundidad de la mesa
n=cantidad de bloques
v=cantidad de pasos
y(x)=ubicacin en eje y de la pila x
h(x)=altura actual de la pila x
f=pila de origen
t=pila de destino:

y(1)
y(2)
y(3)
k
h(1) h(2) h(3)
p
Figura 4. Parmetros Ejercicio

2.3.3 El movimiento bsico que debe realizar la
maquina mostrado en la figura 5

Ir sobre la pila f
Bajar hasta p-h(t)
Activar el electroimn

Subir
Ir sobre la pila t
Bajar hasta p-h(t)-k
Desactivar el electroimn
Subir

t f

Figura 5. Movimiento genrico

3 ESTRUCTURACIN CODIGO CNC

El cdigo necesario para realizar este ejercicio
empieza declarando los parmetros de velocidad
de los ejes y de movimiento en vacio:

wndgs=1,1,1,1
speed=5500,30000,4000,10000
VELOCITY=1000

Pasamos a modo incremental y nos
movemos 10cm en X y Y, bando 1cm en Z para
evitar que al volver lleguemos al final del carrera y
se finalice la ejecucin.

POSMODE=0,0,0,0
move=10000,10000,-100
WAITDONE=1,1,1

Se define la posicin actual como el nuevo 0 y
se regresa a modo absoluto

abspos=0,0,0,0
POSMODE=1,1,1,1

Luego se declara e inicializa la tabla con los
pasos:

DIM m(62,1)
m(0,0)=1
m(1,0)=1
m(2,0)=2
m(3,0)=1
m(4,0)=3
m(5,0)=3
m(6,0)=1
m(7,0)=1
m(8,0)=2
m(32,0)=2
m(33,0)=2
m(34,0)=3
m(35,0)=2
m(36,0)=1
m(37,0)=1
m(38,0)=2
m(39,0)=2
m(40,0)=3
m(0,1)=2
m(1,1)=3
m(2,1)=3
m(3,1)=2
m(4,1)=1
m(5,1)=2
m(6,1)=2
m(7,1)=3
m(8,1)=3
m(32,1)=3
m(33,1)=1
m(34,1)=1
m(35,1)=3
m(36,1)=2
m(37,1)=3
m(38,1)=3
m(39,1)=1
m(40,1)=1
Universidad Nacional de Colombia Automatizacin de Procesos de Manufactura
.


3
m(9,0)=2
m(10,0)=3
m(11,0)=2
m(12,0)=1
m(13,0)=1
m(14,0)=2
m(15,0)=1
m(16,0)=3
m(17,0)=3
m(18,0)=1
m(19,0)=3
m(20,0)=2
m(21,0)=2
m(22,0)=3
m(23,0)=3
m(24,0)=1
m(25,0)=1
m(26,0)=2
m(27,0)=1
m(28,0)=3
m(29,0)=3
m(30,0)=1
m(31,0)=1

m(41,0)=3
m(42,0)=1
m(43,0)=3
m(44,0)=2
m(45,0)=2
m(46,0)=3
m(47,0)=2
m(48,0)=1
m(49,0)=1
m(50,0)=2
m(51,0)=1
m(52,0)=3
m(53,0)=3
m(54,0)=1
m(55,0)=1
m(56,0)=2
m(57,0)=2
m(58,0)=3
m(59,0)=2
m(60,0)=1
m(61,0)=1
m(62,0)=2
m(9,1)=1
m(10,1)=1
m(11,1)=3
m(12,1)=2
m(13,1)=3
m(14,1)=3
m(15,1)=2
m(16,1)=1
m(17,1)=2
m(18,1)=2
m(19,1)=1
m(20,1)=3
m(21,1)=1
m(22,1)=1
m(23,1)=2
m(24,1)=2
m(25,1)=3
m(26,1)=3
m(27,1)=2
m(28,1)=1
m(29,1)=2
m(30,1)=2
m(31,1)=3

m(41,1)=2
m(42,1)=2
m(43,1)=1
m(44,1)=3
m(45,1)=1
m(46,1)=1
m(47,1)=3
m(48,1)=2
m(49,1)=3
m(50,1)=3
m(51,1)=2
m(52,1)=1
m(53,1)=2
m(54,1)=2
m(55,1)=3
m(56,1)=3
m(57,1)=1
m(58,1)=1
m(59,1)=3
m(60,1)=2
m(61,1)=3
m(62,1)=3

Se definen las variables iniciales del programa

p=10000 'profundidad de mesa
k=1000 'grosor disco
n=2 'numero de discos

'coordenadas en y de los postes
DIM y(3)
y(1)=20000
y(2)=40000
y(3)=60000

'altura de discos en cada poste
DIM h(3)
h(1)=3000
h(2)=0
h(3)=0
f=1
t=1

Segn la cantidad de bloques de decide hasta
donde leer la tabla

IF n=1 THEN
v=0
END IF
IF n=2 THEN
v=2
END IF
IF n=3 THEN
v=6
END IF
IF n=4 THEN
v=14
END IF
IF n=5 THEN
v=30
END IF
IF n=5 THEN
v=62
END IF

Ya establecidos los parmetros se ejecuta un
ciclo encargado de recorrer la tabla y ejecutar la
funcin MOVE_DISC, la funcin END al final le
dice a la mquina que tras terminar el ciclo se
acaba el programa.

FOR x=0 TO v STEP 1
f=m(x,0)
t=m(x,1)
GOSUB MOVE_DISC
next x
END

Finalmente la function MOVE_DISC, para
cada paso espera a completarse, al momento de
recoger la pieza tiene un tiempo de espera de 1s y
al final re-calcula las alturas de las pilas, quedando
listo para el siguiente paso

MOVE_DISC:
MOVE=,y(f) 'llega sobre el poste a recoger
WAITDONE=,1
MOVE=,,h(f)-p 'baja a recoger
WAITDONE=,,1
EXOUT(122)=1 'recoge
WAIT=1
MOVE=,,0 'levanta el disco
WAITDONE=,,1
MOVE=,y(t) 'va sobre el poste de destino
WAITDONE=,1
MOVE=,,h(t)+k-p 'baja a dejar
WAITDONE=,,1
EXOUT(122)=0 'deja
MOVE=,,0 'retira la maquina
WAITDONE=,,1

h(f)=h(f)-k
h(t)=h(t)+k
RETURN


4 RECURSIVIDAD

Para la obtencin de los pasos
almacenados en la tabla, se realizo un
programa, en c++ que implementa
recursividad para solucionar el algoritmo, es
Universidad Nacional de Colombia Automatizacin de Procesos de Manufactura
.


4
decir una funcin que se llama a si misma
dentro de si, pues, para mover el bloque
grande de una pila de altura n de la columna
A a la C, se debe primero mover todos los
bloques de menor tamao, es decir una torre
de altura n-1 a la torre B, tras completar este
proceso, mover de nuevo la torre de altura n-1
sobre el bloque ubicado en la pila C.

La funcin usada para este fin es la siguiente:

void torres(int n, char desde,char
hasta,char aux)
{
if(n==1)
{
printf("\nPaso %d: Mover disco %d
de la varilla %c a la varilla %c
\n",x,n,desde,hasta);
x++;
return;
}

torres(n-1,desde,aux,hasta);
printf("\nPaso %d: Mover disco %d de
la varilla %c a la varilla %c
\n",x,n,desde,hasta);
x++;
torres(n-1,aux,hasta,desde);
}


5 CONCLUSIN

Este ejercicio muestra como una maquina a
travs de una funcin simple pero
parametrizada, realizar tareas complejas de
transporte de piezas en un entorno
automatizado.

El lenguaje de programacin puede limitar el
alcance de los algoritmos y la facilidad con que
se pueda resolver el problema, no obstante,
siempre hay diferentes caminos para lograr el
objetivo.