IMPLEMENTACIÓN DE UN ALGORITMO DE CONVERSIÓN

CARTESIANA Y SEGMENTACIÓN DE VECTORES PARA

IMPRESORAS 3D EN CONFIGURACIÓN DELTA

TESIS
PARA OBTENER EL GRADO DE

MAESTRO EN
SISTEMAS INTELIGENTES MULTIMEDIA

PRESENTA

ING. LUIS ARTURO IÑIGUEZ HERNÁNDEZ

GUADALAJARA, JALISCO, ABRIL 2017

I
 Pienso, luego existo.
René Descartes (1596-1650)

I
A mis padres y esposa

II
AGRADECIMIENTOS

A mis padres María Luisa y Jesús por haberme apoyado en todo momento, por sus
consejos, sus valores, por la motivación constante que me ha permitido ser una
persona de bien, pero más que nada por su amor.

A mi esposa Merilú por su incondicional apoyo, paciencia, comprensión y su aliento

para continuar.

A mis maestros quienes influyeron con sus lecciones y experiencias en formarme como
una persona de bien y preparada para los retos que pone la vida.

A mi asesor de tesis Dr. Héctor Torres por su valiosa ayuda al escribir esta tesis.

A mi revisor de tesis Dr. Nery Delgadillo por sus valiosas observaciones y

recomendaciones.

III
RESUMEN

El objetivo de esta tesis es generar los algoritmos requeridos para un sistema de

impresión delta, el cual es necesario para bajar costos de manufactura así como
disminuir tiempos de ensamble. Los algoritmos comprendidos son: conversión de
coordenadas cartesianas a delta y segmentado de vectores. La parte de diseño
mecánico de este proyecto es desarrollado por otro ingeniero de ese desarrollo se
obtendrán los valores, medidas y datos del diseño mecánico de la impresora delta. El
desarrollo se basa en un firmware anterior usado en la impresora cartesiana, este
desarrollo se integra a ese firmware.

La conversión de coordenadas cartesianas a coordenadas delta se realiza dentro del

sistema operativo embebido en la impresora, este es necesario para convertir el
sistema tradicional cartesiano a sistema de coordenadas delta, para esta conversión
se necesita tener bien definidos las medidas de las partes mecánicas de la impresora.
El segmentado de vectores es necesario ya que en un sistema delta el camino natural
entre 2 puntos no es una línea recta, en este caso el movimiento es de péndulo por lo
que el segmentado de los vectores de movimiento minimiza el efecto péndulo y hace
que la impresión sea viable.

Los resultados son satisfactorios ya que con este sistema se redujo el costo hasta un 70%
debido a que no requiere de memoria adicional, así como también fueron reducidas
las dimensiones de impresión, con una reducción no aparente en la precisión de la
superficie de la impresión.

IV
ÍNDICE DE CONTENIDO

Cita……………..…………………………………………………………………………………I

Dedicatoria…..……………………………………………………………………………...….II

Agradecimientos……..……………………………………………………………………….III

Resumen……………………...……………………………………………………………...…IV

Índice de contenido………………..………………………………………………………...V

Glosario…………….....………………………………………………………………………..VII

Capítulo 1 introducción…………….………………….……………………………………..1

1.1 Antecedentes………………………….………………………….……………….1

1.2 Definición del problema…………….…….……………………………………..1

1.3 Justificación…………………………………………………..…………………….1

1.4 Objetivos.………………………………………………………………………...….2

1.5 Hipótesis……………………………………..……………………………………….2

Capítulo 2 marco teórico……….……………………………………………………………3

2.1 Impresoras 3D.………..………………………………………………………….…3

2.1.1 Impresora cartesiana……………..…………………………………….3

2.1.2 Impresora delta…….…………………………………………………….3

2.1.3 Impresora SCARA.……………………………………………………….4

2.2 Control de impresoras delta…………………………………………….………4

2.3 Conclusión………………………………………………………………………..…6

Capítulo 3 procedimientos de investigación……….……………………………………7

3.1 Conversor coordenadas cartesianas a delta……………………………….7

V
 3.2 Segmentador………………………………………………….……………………7

Capítulo 4 resultados……………………………………………………...………………..…9

4.1 Resultados conversor coordenadas cartesianas a delta…....…………....9

4.2 Resultados segmentador……………………………...………………………..13

4.3 Resultados uso de memoria del firmware resultante……………………..16

5 Conclusiones……………………………………………………………...………………...17

6 Recomendaciones……………………………………………………...…………………18

7 Referencias bibliográficas………………………………………………………………..19

8 Anexos………………………………………………………………………………………..21

8.1 Anexo A Delta.c..…...……………………………………………………………22

8.2 Anexo B Delta.h..………..….…………………………………………………….29

8.3 Anexo C Segmentador.cs……...………….…………………………………...31

VI
GLOSARIO

Robot Delta.- Es un tipo de robot paralelo de tres grados de libertad conformado por
dos bases unidas por tres cadenas cinemáticas basadas en el uso de Paralelogramos.
La base superior se encuentra fija mientras la base inferior, donde se ubica el efector
final, es móvil y siempre está paralela a la base fija.

RepRap.- Es una iniciativa con el ánimo de crear una máquina autorreplicable que
puede ser usada para prototipado rápido y manufactura.

Firmware.- Es un programa informático que establece la lógica de más bajo nivel que
controla los circuitos electrónicos de un dispositivo de cualquier tipo. Está fuertemente
integrado con la electrónica del dispositivo, es el software que tiene directa interacción
con el hardware, siendo así el encargado de controlarlo para ejecutar correctamente
las instrucciones externas.

Robot SCARA.- Acrónimo que responde por sus siglas en inglés a Selective Compliant
Assembly Robot Arm o Selective Compliant Articulated Robot Arm, es un robot de
cuatro grados de libertad con posicionamiento horizontal. Los Robots SCARA se
conocen por sus rápidos ciclos de trabajo, excelente repetitividad, gran capacidad de
carga y su amplio campo de aplicación.

Robot PUMA.- Acrónimo que responde por sus siglas en inglés Programmable Universal
Machine for Assembly, o Programmable Universal Manipulation Arm, es un brazo robot
industrial desarrollado por Victor Scheinman en la empresa pionera en robótica
Unimation. Inicialmente desarrollado para General Motors, el brazo robot PUMA nació
de los diseños iniciales inventados por Scheinman mientras se encontraba en el MIT y en
la Stanford University.

Memoria RAM.- Memoria de acceso aleatorio (Random Access Memory) se utiliza

como memoria de trabajo de computadoras para el sistema operativo, los programas
y la mayor parte del software. En la RAM se cargan todas las instrucciones que ejecuta
la unidad central de procesamiento (procesador) y otras unidades del computador.

VII
Memoria EEPROM.- ROM programable y borrable eléctricamente. Es un tipo de
memoria ROM que puede ser programada, borrada y reprogramada eléctricamente.
Son memorias no volátiles.

Memoria ROM.- La memoria de sólo lectura, conocida también como ROM (acrónimo
en inglés de read-only memory), es un medio de almacenamiento utilizado en
ordenadores y dispositivos electrónicos, que permite solamente la lectura de la
información y no su escritura, independientemente de la presencia o no de una fuente
de energía.

G-Code.- El lenguaje de programación más usado en Control numérico (CNC), el cual

posee múltiples implementaciones. Usado principalmente en automatización, forma
parte de la ingeniería asistida por computadora. Al G-code se le llama en ciertas
ocasiones lenguaje de programación G.

CNC.- Es un sistema de automatización de máquinas herramienta que son operadas

mediante comandos programados en un medio de almacenamiento, en
comparación con el mando manual mediante volantes o palancas.

PWM.- La modulación por ancho de pulsos (también conocida como PWM, siglas en
inglés de pulse-width modulation) de una señal o fuente de energía es una técnica en
la que se modifica el ciclo de trabajo de una señal periódica (una senoidal o una
cuadrada, por ejemplo), ya sea para transmitir información a través de un canal de
comunicaciones o para controlar la cantidad de energía que se envía a una carga.

Ciclo de trabajo.- Es el porcentaje o relación que existe entre el tiempo en que la señal
se encuentra en estado activo y el periodo de la misma.

Kernel.- Es un software que constituye una parte fundamental del sistema operativo, y
se define como la parte que se ejecuta en modo privilegiado (conocido también
como modo núcleo). Es el principal responsable de facilitar a los distintos programas
acceso seguro al hardware de la computadora o en forma básica, es el encargado de
gestionar recursos, a través de servicios de llamada al sistema.

VIII
Microcontrolador.- Es un circuito integrado programable, capaz de ejecutar las
órdenes grabadas en su memoria. Está compuesto de varios bloques funcionales, los
cuales cumplen una tarea específica. Un microcontrolador incluye en su interior las tres
principales unidades funcionales de una computadora: unidad central de
procesamiento, memoria y periféricos de entrada/salida.

Extrusor.- Elemento electrónico-mecánico, el cual se encarga de fundir el material de

impresión y posteriormente la deposición del mismo.

Coordenadas polares.- Son un sistema de coordenadas bidimensional en el que cada

punto del plano se determina por una distancia y un ángulo

IX
CAPÍTULO 1 INTRODUCCIÓN

1.1 ANTECEDENTES

La impresión 3D ha revolucionado la manufactura aditiva haciéndola más versátil y

accesible [1]. El presidente de los Estados Unidos Barak Obama dijo el 12 febrero de
2013 que: el creciente campo de la impresión 3D recibió un gran impulso, lo destacó
como algo que podría alimentar nuevos empleos de alta tecnología en los Estados
Unidos y destacó la importancia de la impresión 3D como parte de su estrategia
nacional [2].

La impresión 3D todavía no se considera un producto de consumo masivo. El primer

artículo sobre el estudio de la manufactura de un sólido impreso se publicó en 1981 por
Hideo Kodama [3] y hasta la fecha la impresión 3D no se ha convertido en un artículo
de uso común pese a su gran utilidad, principalmente debido al alto costo tanto del
dispositivo como de los materiales que usa [3].

El sistema cartesiano de coordenadas en las impresoras 3D es el más usado pero el

costo de ensamble y número de piezas es alto. El uso de sistema de posicionamiento
delta es preferido en la industria robótica debido a su velocidad [4] y menor número de
piezas [5].

1.2 DEFINICIÓN DEL PROBLEMA

El uso del sistema cartesiano en las impresoras 3D genera altos costos de manufactura y
ensamble, debido al alto número de piezas que conlleva este sistema.

1.3 JUSTIFICACIÓN

El uso de un sistema cartesiano de coordenadas en la impresión 3D provoca que el

ensamble de la impresora 3D posea un gran número de piezas y un elevado tiempo de
ensamble así como también diversos materiales y elevada mano de obra, por lo tanto
el precio se incrementa. El alto costo actual de estos dispositivos es una de las razones

1
por las que la impresión 3D todavía no puede ser de consumo masivo. El problema del
alto costo podrá ser solucionado con la implementación del sistema delta para
impresión 3D, desarrollando un algoritmo de conversión cartesiana y segmentación de
vectores para impresoras 3D en configuración delta [6] [7].

1.4 OBJETIVOS

• Desarrollo e implementación de algoritmo de conversión cartesiana a delta.

• Desarrollo e implementación de algoritmo de segmentación de vectores.

1.5 HIPÓTESIS

El desarrollo de un sistema de algoritmos en sistema embebido para un sistema delta

de impresión 3D podría ayudar a reducir el tiempo de desarrollo en nuevos proyectos;
así como posiblemente reducir el costo y tiempo de ensamble del producto.

2
CAPÍTULO 2 MARCO TEÓRICO

2.1 Impresoras 3D

2.1.1 impresora cartesiana

El sistema de coordenadas cartesianas consiste de 3 ejes; X, Y, Z como se puede

apreciar en la figura 1. Cada eje se mueve en un solo plano, es decir, izquierda-
derecha (X), adelante-atrás (Y) y arriba-abajo (Z).

Figura 1: Impresora Cartesiana. Fuente: PwC analysis

2.1.2 impresora delta

En las impresoras tipo delta, como se puede apreciar en la figura 2, el extrusor se

encuentra suspendido y es posicionado mediante 3 brazos articulados. Los brazos se
deslizan hacia arriba y abajo en el eje Z sobre guías verticales que se encuentran en
una configuración triangular.

Figura 2: Impresora Delta. Fuente: PwC analysis

3
2.1.3 impresora SCARA

En las impresoras tipo SCARA, como se puede apreciar en la figura 3, se compone de 2

brazos y 3 articulaciones, las articulaciones 1 y 2 son giratorias y rotan en el mismo
plano, la articulación 3 es lineal y se mueve en el eje Z, los movimientos son controlados
mediante coordenadas polares.

Figura 3: Brazo SCARA. Fuente: Mark Meier

2,2 control de impresoras delta

Los desarrollos más utilizados para el control de impresoras delta son los que se
describen a continuación:

Marlin es el programa desarrollado en C++ más utilizado de control de trayectorias

para Delta, es un firmware para impresoras tipo RepRap. Según las necesidades del
usuario, puede configurarse para que funcione correctamente en diferentes tipos de
máquina. Soporta hasta 4 extrusores. También es compatible con pantallas LCD y
tarjetas SD. Proporciona soporte a impresoras cartesianas, delta y SCARA. Es un
proyecto de código abierto.

El firmware Aprinter es otro de los programas más utilizados. Este programa es

compatible con multitud de microcontroladores, por ejemplo diferentes modelos AVR,

4
AT91SAM, STM32F4 y NXP (antes Freescale) MK20. Ofrece soporte para arquitecturas
tipo delta, delta rotativo y CoreXY. Se pueden utilizar otras configuraciones si se
implementan las transformaciones de coordenadas directa e inversa, siempre que el
microcontrolador disponga de suficiente memoria RAM. Utiliza temporizadores
hardware separados para cada motor, por lo que tiene una alta precisión [8].

También existe el siguiente desarrollo:

LinuxCNC es un programa informático de código abierto dispone de las siguientes

características:

•Diferentes interfaces graficas de usuario, entre ellos uno para pantallas táctiles.
•Interprete para G-code.
•Puede controlar simultáneamente hasta 9 ejes y soporta variedad de interfaces.
•El control puede operar tanto con servos analógicos como PWM con el lazo de
realimentación cerrado y también con motores de pasos.
•Las características del control de movimiento incluyen compensación de radios y de
longitud, desviación de trayectoria limitada a una tolerancia específica, roscado
sincronizado para el torno, sincronización de ejes, avance de trabajo adaptativo,
control de avance por el operario o control de velocidad constante.

•Soporta sistemas de movimiento no cartesianos a través de módulos cinemáticos

personalizados. Dispone de arquitecturas como hexápodos y sistemas con uniones
rotativas para controlar el movimiento de robots como el PUMA o el SCARA.
•Utiliza la extensión de tiempo real de Linux y actualmente soporta las versiones 2.4 y
2.6 del kernel de Linux con las extensiones de tiempo real aplicadas por RT-Linux o el
parche RTAI. [9]

Los desarrollos más comunes (RepRap, LinuxCNC, Marlin) mencionados anteriormente,

tienen como desventaja que requieren una gran cantidad de recursos del
microcontrolador, por lo tanto, requieren un microcontrolador mas potente [10]. Estos
desarrollos cuentan con funciones que no serán utilizadas en nuestra impresora delta,

5
así como son diseñados multi-plataforma y por consecuente requieren mas memoria, lo
que limita su aplicabilidad y encarece el proyecto [11].

2.3 Conclusión

La finalidad del desarrollo del modelo de algoritmos embebidos para un sistema delta
de impresión 3D es lograr el mismo nivel de control de una manera más sencilla. Con el
algoritmo propuesto se puede utilizar una menor cantidad de recursos y que por lo
tanto se puede implementar en un mayor número de equipos con microcontroladores
con recursos limitados. En el caso del desarrollo en cuestión se utilizó un
microcontrolador Kinetis k20 con un CPU de 120 MHz, 512 KB de memoria flash y 128 KB
de SRAM. Este microcontrolador fue seleccionado por cumplir con las características
necesarias para el control de la impresora (Memoria, comunicación, velocidad de
procesamiento y temporización) su bajo costo y porque ha sido utilizado para
proyectos anteriores comprobando así su confiablidad, esta elección quedo a cargo
del equipo de desarrollo electronico y su elección queda fuera del alcance de este
desarrollo.

6
CAPÍTULO 3 PROCEDIMIENTOS DE INVESTIGACIÓN

3.1 CONVERSOR COORDENADAS CARTESIANAS A DELTA

La investigación que se llevó a cabo es conocida como experimental, se realizó

indagando las formulas necesarias para la conversión a delta las cuales son: calcula
de las posiciones de los pivotes, calculo de las posiciones de los carros en X-Y, calculo
de las distancias del plano X-Y de los pivotes de los puntales y calculo de las alturas de
los carros sobre el piso de la impresora. Posteriormente se aplicaron para realizar
pruebas y después, se realizaron las correcciones pertinentes.

El sistema embebido al que se aplico este algoritmo es un firmware previamente

desarrollado para el control del producto anterior, la impresora cartesiana.

3.2 SEGMENTADOR

Al realizar las pruebas de movimiento del cabezal de impresión se observó un

movimiento de péndulo entre 2 puntos el cual no permitía una buena calidad de
impresión y se determinó que era necesario otra solución para corregir el efecto, el
método que se utilizó para corregirlo fue el método científico. Después de observar el
problema se formó una hipótesis la cual fundo la teoría de que en el caso de la
impresora delta el movimiento más rápido entre 2 puntos se trata de un movimiento de
péndulo, para solucionar esto, se generó un programa que convierte los trayectos
mayores a 5mm en secciones equidistantes que no sobrepasan los 5mm y en conjunto
forman el mismo vector. Con este programa se logró corregir el problema y por lo tanto
obtener una impresión de mayor calidad. La calidad en una impresión esta en función
de la exactitud dimensional y la estabilidad dimensional así como también de la
textura de la superficie [12].

Las pruebas de movimiento del cabezal de impresión fueron realizadas para constatar
que el área de impresión previsto pudiera ser alcanzado, se utilizaron vectores con
altura en eje Z=0, al ejecutar los movimientos vectoriales se pudo observar el

7
movimiento de péndulo ocasionando que el cabezal de impresión se bajara
posicionándose en valores negativos en el eje Z (Figura 4).

Figura 4: Dibujo simple representado en 2 dimensiones mostrando el movimiento tipo

péndulo (color verde) entre 2 puntos de la impresora delta.

8
CAPÍTULO 4 RESULTADOS

4.1 RESULTADOS CONVERSOR COORDENADAS CARTESIANAS A DELTA

La solución de conversión de coordenadas que se puede observar en los anexos A y B,

fue programada en lenguaje C en el IDE CodeWarrior, se usaron como base los valores
de la tabla 1.

Tabla 1: Constantes de dimensiones de la impresora.

CONSTANTES

Constante Descripción Valor

la Longitud del brazo 138.5 mm
po Desfase del pivote 53.6 mm
to Desfase de la herramienta 34.9 mm
sp Distancia del centro al puntal 122.195 mm

Las cuales están basadas en las mediciones de la impresora como se puede observar
en la figura 5.

9
 Figura 5: Mediciones de una impresora tipo delta.

En la figura 6 se muestran las posiciones de los carros (carriages) A, B y C, estos son

calculados con el siguiente procedimiento:

10
 Figura 6: Mediciones de una impresora tipo delta.

Las posiciones de los pivotes véase figura 7, se calculan usando los datos contenidos en
la tabla 2.

Tabla 2: Cálculo de las posiciones de los pivotes.

Pivote A Pivote B Pivote C
!1! = !" + !" !1! = !" + !" !"#120 !1! = !" + !" !"#240
!1! = !" !1! = !" + !" !"#120 !1! = !" + !" !"#240
!1! = !" + !" !1! = !" + !" !1! = !" + !"

11
 Figura 7: Posiciones de los pivotes de un impresora delta.

Conocemos la posición del carro en X e Y ya que se encuentran fijados a las posiciones

de los puntales (struts) pero se desconoce la altura como se muestra en la tabla 3.

Tabla 3: posiciones de los carros en X Y.

Carro A Carro B Carro C
!2! = !" !2! = (!")(!!"120) !2! = (!")(!"#240)
!2! = 0 !2! = !" !"#120 !2! = !" !"#240
!2! =? !2! =? !2! =?

Las distancias del plano x-y de los pivotes de los puntales son proporcionados por:

!! = !2! − !1! ! + !2! − !1! !

!" = !2! − !1! ! + !2! − !1! !

!" = !2! − !1! ! + !2! − !1! !

Y por lo tanto las alturas de los carros por encima del pivote son:

12
 ℎ! = !" ! – !! !

ℎ! = !" ! – !" !

ℎ! = !" ! – !" !

Por lo que las alturas de los carros sobre el piso de la impresora finalmente son:

!2! = !" + !" + ℎ!

!2! = !" + !" + ℎ!
!2! = !" + !" + ℎ!

4.2 RESULTADOS SEGMENTADOR

El segmentador de trayectorias véase Anexo C recibe un archivo GCode como

entrada y genera un segundo archivo GCode como salida, se lee línea por línea el
archivo GCode de entrada, las líneas de comandos o comentarios son escritas
íntegramente en el archivo de salida ya que no se les aplica ningún tratamiento. Por lo
tanto solo se procesan coordenadas de movimiento, estas coordenadas son
estructuradas en el código de la siguiente manera: G1 F1200 X-7.480 Y-7.480 Z0.200
E1.96517 En donde:

G.- Es el tipo de trayecto a realizar, en este caso G1 es un trayecto con extrusión.

F.- Rapidez con la que se ejecutara el movimiento.
X.- Posición en el eje X.
Y.- Posición en el eje Y.
Z.- Posición en el eje Z.
E.- Cantidad de extrusión.

Las mediciones puedes estar en sistema métrico o inglés, regularmente se utiliza el

sistema métrico, esto se le específica a la impresora mediante el comando: G21.

13
 Figura 8: Diagrama de flujo del segmentador de vectores.

Los vectores que realizara la impresora se interpretan tomando la última coordenada

ejecutada como punto inicial y la siguiente coordenada como punto final.

A cada coordenada se le separa y se almacena en sus diferentes partes (G, F, X, Y, Z,

E) se calcula la distancia entre la línea actual y la anterior con la siguiente formula:

14
Donde X2, Y2 es la coordenada actual y X1, Y1 es la coordenada anterior, en el caso
de tratarse de la primera línea leída la coordenada anterior es X=0, Y=0 ya que la
impresión comienza en el centro.

Una vez obtenida la distancia se verifica si sobrepasa el segmento máximo, que en este
caso se trata de 5mm, si la distancia es mayor se calcula el número de veces que se
segmentara con la siguiente formula:

numeroDeSegmentacion = (int)Math.Floor(dist / segmentoMaximomm);

Después se calculan los nuevos vectores iterando según el numeroDeSegmentacion y

sumándole a los valores temporales la porción del vector y la extrusión que le
corresponde de la siguiente manera:

for (int i = 0; i < numeroDeSegmentacion; i++)

{
lineatemp = "";
x = xtemp + ((xact - xant) / numeroDeSegmentacion);
y = ytemp + ((yact - yant) / numeroDeSegmentacion);
z = ztemp + ((zact - zant) / numeroDeSegmentacion);
e = etemp + ((eact - eant) / numeroDeSegmentacion);
⋮
}

En donde xtemp, ytemp, ztemp y etemp, contienen los valores utilizados en la

generación del último segmento.

Con los valores obtenidos anteriormente (x, y, z, e) se genera la nueva línea a insertar
en el archivo de salida y se guardan los valores temporales de la siguiente manera:

lineatemp = "G" + g + " F" + f + " X" + x.ToString("f3") + " Y" + y.ToString("f3") + " Z" +
z.ToString("f3") + " E" + e.ToString("f5");
xtemp = x; ytemp = y; ztemp = z; etemp = e;

15
Finalmente una vez recorrido todo el archivo de entrada obtenemos un archivo muy
similar al de entrada pero con los trayectos mayores a 5mm divididos en segmentos no
mayores a 5mm véase figura 9.

Figura 9: Procesamiento del segmentador de vectores.

4.3 RESULTADOS USO DE MEMORIA DEL FIRMWARE RESULTANTE

Debido al código compacto el ahorro en memoria fue significativo, el firmware

resultante utiliza solo 320 KB de memoria para almacenar su código, como se puede
observar en la Tabla 4.

Tabla 4: Comparativa entre el desarrollo local y los firmwares mas populares.

Firmware / sistema operativo Uso de memoria

Desarrollo local 320KB
Aprinter 377KB
Marlin Delta 589KB
LinuxCNC 1.1GB

16
5 CONCLUSIONES

El objetivo de desarrollar e implementar estos algoritmos embebidos para un sistema

delta de impresión 3D se logró de manera satisfactoria. Este algoritmo se validó con la
impresión de varias piezas de referencia para ambas configuraciones véase figura 10.
Este algoritmo presenta como ventaja el ahorro en recurso computacional debido a su
código compacto, un 55% menor que el firmware Marlin Delta uno de los firmwares
más compactos para impresoras delta con un peso de 589KB, contra el que se obtuvo
un ahorro de 269KB. Además es un módulo que se puede integrar fácilmente a un
desarrollo previo sin perder control sobre el hardware. A diferencia de los desarrollos
existentes, los cuales son programas con funcionalidades diversas que requieren de
memoria y procesamiento considerable.

Figura 10: En las fotografías a y b se observa un modelo de referencia impreso por la

configuración cartesiana, en las c y d los mismos modelos con la impresora delta.

17
6 RECOMENDACIONES

Además de las mejoras definidas por las pruebas al desarrollo se listan a continuación,
tareas pendientes y áreas de oportunidad para mejorar, corregir y extender el
proyecto planteado en esta tesis.

El algoritmo de conversión se puede mejorar para no necesitar el segmentador, es

decir mejorar los trayectos para que sean líneas rectas y de esta manera obtener una
mejor calidad de impresión.

El desarrollo se puede traducir a mas lenguajes de programación adaptándose así a la

plataforma utilizada en el desarrollo al que será aplicado.

18
7 REFERENCIAS BIBLIOGRÁFICAS

[1] Prince, J. D. (2014). 3D printing: an industrial revolution. Journal of electronic

resources in medical libraries, 11(1), 39-45.

[2] Hui Wang & Masami Sano. (2013) A Study of Spreading 3D Image Technology in
Medical Industry. (49), 75-88, 2013-07 Information Research, Bunkyo University.

[3] Pîrjan, A., & Petroşanu, D. M. (2013). THE IMPACT OF 3D PRINTING TECHNOLOGY ON
THE SOCIETY AND ECONOMY. Journal of Information Systems & Operations
Management, 7(2), 360-370.

[4] Celi, R., Sempértegui, A., Morocho, D., Loza, D., Alulema, D., & Proaño, M. (2015,
October). Study, design and construction of a 3D printer implemented through a delta
robot. In Electrical, Electronics Engineering, Information and Communication
Technologies (CHILECON), 2015 CHILEAN Conference on (pp. 717-722). IEEE.

[5] Pierrot, F., Reynaud, C., & Fournier, A. (1990). DELTA: a simple and efficient parallel
robot. Robotica, 8(02), 105-109.

[6] Wu, C., Yi, R., Liu, Y. J., He, Y., & Wang, C. C. (2016, October). Delta DLP 3D printing
with large size. In Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International
Conference on (pp. 2155-2160). IEEE.

[7] Álvarez-Cedillo, J. A., Sandoval-Gutierrez, J., Herrera-Lozada, J. C., de Jesús Medel-

Juárez, J., & Olguín-Carbajal, M. (2016). Diseño, fabricación y funcionamiento de un
robot delta de bajo costo. DYNA-Ingeniería e Industria, 91(3).

[8] MARTÍNEZ MARTÍNEZ, A. B. E. L. (2015). Mejora del sistema de control para impresoras
3D.

19
[9] Tajti, F., Szayer, G., Kovács, B., & Korondi, P. (2013, November). Universal rt-
middleware robot controller. In Industrial Electronics Society, IECON 2013-39th Annual
Conference of the IEEE (pp. 7862-7867). IEEE.

[10] Wijnen, B., Anzalone, G. C., Haselhuhn, A. S., Sanders, P. G., & Pearce, J. M. (2016).
Free and open-source control software for 3-D motion and processing. Journal of Open
Research Software, 4(1).

[11] Allebach, J. P. (2004, January). Digital Printing-An Image Processor's Perspective. In

IS&T/SPIE 16 th Annual Symposium on Electronic Imaging Science and Technology (2004
Electronic Imaging Scientist of the Year Plenary Address), San Jose, CA (Vol. 20).

[12] Dimitrov, D., Van Wijck, W., Schreve, K., & De Beer, N. (2006). Investigating the
achievable accuracy of three dimensional printing. Rapid Prototyping Journal, 12(1), 42-
52.

20
8 ANEXOS

21
8.1 ANEXO A
Delta.c

22
#include "Delta.h"
#include "math.h"
#include "localmath.h"

static const float COSSENVAL = -0.5;

static const float SENPVAL = 0.866025;
static const float SENNVAL = -0.866025;
/*#pragma define_section mySectionInRAM ".myCodeInRAM" far_abs RX
#pragma section mySectionInRAM begin*/
static float arm_lenght = 138.15;//141.3;//136.50;//ARM_LENGHT;
/*static float arm_lenghtC = 145.5;*/
static float pivote_offset = 53.6;//54.99;//53.99;//PIVOTE_OFF;
static float tool_offset = 34.9;//35.5;//28.38;//TOOL_OFF;
static float strut_pitch = 122.195;//127.90;//122.195;//STRUT_PITCH;

static float pAtostrut;

static float pBtostrut;
static float pCtostrut;

static float HeightA;

static float HeightB;
static float HeightC;

float Z_HeightA;
float Z_HeightB;
float Z_HeightC;

float Z_auxHA;
float Z_auxHB;
float Z_auxHC;

23
float Z_Init;

typedef struct
{
float cx;
float cy;
float cz;
}Carriage_t;

typedef struct
{
float px;
float py;
float pz;
}Pivot_t;

typedef Carriage_t Carriage_p;

Carriage_p Carriage_A;
Carriage_p Carriage_B;
Carriage_p Carriage_C;

typedef Pivot_t Pivot_p;

Pivot_p Pivot_A;
Pivot_p Pivot_B;
Pivot_p Pivot_C;

//#pragma section mySectionInRAM end

void Carriage_Calculations(float tool_X, float tool_Y, float tool_Z)
{

24
/*****************************************************************************
*****************************************************************************
* Calculate Pivot A
*
*
****************************************************************************/
Pivot_C.py = tool_X + pivote_offset;
Pivot_C.px = tool_Y;
Pivot_C.pz = tool_Z + tool_offset;
/*****************************************************************************
*****************************************************************************
* Calculate Pivot B
*
*
****************************************************************************/
Pivot_B.py = tool_X + (pivote_offset*(COSSENVAL));
Pivot_B.px = tool_Y + (pivote_offset*(SENPVAL));
Pivot_B.pz = tool_Z + tool_offset;
/*****************************************************************************
*****************************************************************************
* Calculate Pivot C
*
*
****************************************************************************/
Pivot_A.py = tool_X + (pivote_offset*(COSSENVAL));
Pivot_A.px = tool_Y + (pivote_offset*(SENNVAL));
Pivot_A.pz = tool_Z + tool_offset;
/*****************************************************************************
*****************************************************************************
* Calculate Carriage A
*
*

25
 ****************************************************************************/
Carriage_C.cy = strut_pitch;
Carriage_C.cx = 0;
/*****************************************************************************
*****************************************************************************
* Calculate Carriage B
*
*
****************************************************************************/
Carriage_B.cy = strut_pitch * COSSENVAL;
Carriage_B.cx = strut_pitch * SENPVAL;
/*****************************************************************************
*****************************************************************************
* Calculate Carriage C
*
*
****************************************************************************/

Carriage_A.cy = strut_pitch * COSSENVAL;

Carriage_A.cx = strut_pitch * SENNVAL;
/*****************************************************************************
*****************************************************************************
* Calculate distance of the pivots to the struts
*
*
****************************************************************************/
pAtostrut = sqrt((Carriage_A.cx-Pivot_A.px)*(Carriage_A.cx-Pivot_A.px) +
(Carriage_A.cy-Pivot_A.py)*(Carriage_A.cy-Pivot_A.py));
pBtostrut = sqrt((Carriage_B.cx-Pivot_B.px)*(Carriage_B.cx-Pivot_B.px) +
(Carriage_B.cy-Pivot_B.py)*(Carriage_B.cy-Pivot_B.py));
pCtostrut = sqrt((Carriage_C.cx-Pivot_C.px)*(Carriage_C.cx-Pivot_C.px) +
(Carriage_C.cy-Pivot_C.py)*(Carriage_C.cy-Pivot_C.py));
/*****************************************************************************

26
*****************************************************************************
* Calculate Heights of carriages above the pivot
*
*
****************************************************************************/
HeightA =(sqrt((arm_lenght * arm_lenght)-(pAtostrut * pAtostrut)));
HeightB =(sqrt((arm_lenght * arm_lenght)-(pBtostrut * pBtostrut)));
HeightC =(sqrt((arm_lenght * arm_lenght)-(pCtostrut * pCtostrut)));
/*****************************************************************************
*****************************************************************************
* Calculate Heights of carriages above the floor (bed)
*
*
****************************************************************************/
Z_HeightA = tool_Z + tool_offset + HeightA;
Z_HeightB = tool_Z + tool_offset + HeightB;
Z_HeightC = tool_Z + tool_offset + HeightC;

/*****************************************************************************
*****************************************************************************
* Calculate Total Heights
*
* V1: step motors under the bed
* V2: step motors in the top with Acrylics
*
*
****************************************************************************/
//Z_Init = TOTAL_HIGH - ZERO_POS;//Z_HeightA;
//Z_Init = 330.95 - 168.2;// @New Home V1 tested
//Z_Init = 330.95 - 143.9;// @New Home V2 tested
//Z_Init = 330.95 - 149.5; // @New Home V? Calibration undergoing
//Z_Init = 327.70 - 149.5; // @New Home V? Calibration undergoing
//Z_Init = 331.70 - 150.0;

27
 Z_Init = 331.00 - 150.0;
Z_HeightA = (Z_Init - Z_HeightA); //* -1;
Z_HeightB = (Z_Init - Z_HeightB); //* -1;
Z_HeightC = (Z_Init - Z_HeightC); //* -1;

/*printf("HeightA:%f\n",Z_HeightA);
printf("HeightB:%f\n",Z_HeightB);
printf("HeightC:%f\n",Z_HeightC);*/

28
8.2 ANEXO B
Delta.h

29
#ifndef DELTA_H_
#define DELTA_H_

#define ARM_LENGHT 133.5//137.75//137.75//160//137.75

#define PIVOTE_OFF 53.6//40.44//51.27
#define TOOL_OFF 23.31//38.85
#define STRUT_PITCH 119.195//119.4
#define PI 3.14159265

#define TOTAL_HIGH 328.95//330.95//339.2//338//295.75//358.67

#define ZERO_POS 196.8//129.86//146.1//172.12//149.65

#define HOME_POS_DISTANCE (TOTAL_HIGH - ZERO_POS)

#define XSELECT (1)

#define YSELECT (2)
#define ZSELECT (3)

void Carriage_Calculations(float, float, float);

extern float Z_HeightA;

extern float Z_HeightB;
extern float Z_HeightC;

extern float Z_auxHA;

extern float Z_auxHB;
extern float Z_auxHC;
extern float Z_init;

extern char first_time;

#endif /* DELTA_H_ */

30
8.3 ANEXO C
Segmentador.cs

31
using System.Data;
using System.Text;
using System.IO;
namespace ProyectoSegmentador {
public class Segmentador {
//metodo que lee un archivo (ArchivoEntrada) gcode segmenta los vectores en
pedazos menores o iguales que segmentoMaximomm (se recomienda 5mm) y genera
un nuevo Gcode segmentado (ArchivoSalida)
//se declara static ya que no es necesario generar un objeto para utilizar el
metodo
public static void segmentaVectores(string ArchivoEntrada, string ArchivoSalida,
segmentoMaximomm) {
StreamReader sr = new StreamReader(ArchivoEntrada);
StreamWriter sw = new StreamWriter(ArchivoSalida);
string temp = sr.ReadToEnd();
string[] arreglo = temp.Split(new string[] { Environment.NewLine },
StringSplitOptions.None);
double g = 0, f = 0, x = 0, y = 0, z = 0, e = 0;
double xant = 0, yant = 0, zant = 0, eant = 0;
double xact = 0, yact = 0, zact = 0, eact = 0;
int numeroDeSegmentacion = 0;
string lineatemp = "";
bool zCambio = false;

foreach (string cadena in arreglo) {

if (cadena.StartsWith("M") || cadena.StartsWith(";")) {
sw.WriteLine(cadena);//se pasa directo al archivo
}
else if (!cadena.StartsWith(";")) {
if (cadena != "") {
string[] segmentos = cadena.Split(' ');
foreach (string seg in segmentos)
{

32
 if (seg != "") {
switch (seg.ToCharArray()[0]) {
case 'G':
g = double.Parse(seg.Substring(1));
break;
case 'F':
f = double.Parse(seg.Substring(1));
break;
case 'X':
xact = double.Parse(seg.Substring(1));
break;
case 'Y':
yact = double.Parse(seg.Substring(1));
break;
case 'Z':
zact = double.Parse(seg.Substring(1));
zCambio = true;
break;
case 'E':
eact = double.Parse(seg.Substring(1));
break;
}
}
}
if (xact == 0 && yact == 0 && zact == 0 && eact != 0) {
sw.WriteLine(cadena);
eant = eact;
}
else if (xact != 0 || yact != 0 || zact != 0 || eact != 0) {
double dist = Math.Sqrt(Math.Pow(xact - xant, 2) + Math.Pow(yact -
yant, 2));
numeroDeSegmentacion = (int)Math.Floor(dist / segmentoMaximomm);
if (numeroDeSegmentacion == 0)

33
 numeroDeSegmentacion = 1;
double xtemp = xant, ytemp = yant, ztemp = zant, etemp = eant;
if (numeroDeSegmentacion == 1) {
sw.WriteLine(cadena);
if(zact!=0)
zant = zact;
xant = xact; yant = yact; eant = eact;
}
else {
for (int i = 0; i < numeroDeSegmentacion; i++) {
lineatemp = "";
x = xtemp + ((xact - xant) / numeroDeSegmentacion);
y = ytemp + ((yact - yant) / numeroDeSegmentacion);
z = ztemp + ((zact - zant) / numeroDeSegmentacion);
e = etemp + ((eact - eant) / numeroDeSegmentacion);
if (zCambio) {
if (eact == eant) {
if (f == 0)
lineatemp = "G" + g + " X" + x.ToString("f3") + " Y" +
y.ToString("f3") + " Z" + z.ToString("f3");
else
lineatemp = "G" + g + " F" + f + " X" + x.ToString("f3") + " Y" +
y.ToString("f3") + " Z" + z.ToString("f3");
}
else {
if (f == 0)
lineatemp = "G" + g + " X" + x.ToString("f3") + " Y" +
y.ToString("f3") + " Z" + z.ToString("f3") + " E" + e.ToString("f5");
else
lineatemp = "G" + g + " F" + f + " X" + x.ToString("f3") + " Y" +
y.ToString("f3") + " Z" + z.ToString("f3") + " E" + e.ToString("f5");
}
}

34
 else {//z no cambio
if (eact == eant) {
if (f == 0)
lineatemp = "G" + g + " X" + x.ToString("f3") + " Y" +
y.ToString("f3");
else
lineatemp = "G" + g + " F" + f + " X" + x.ToString("f3") + " Y" +
y.ToString("f3");
}
else {
if (f == 0)
lineatemp = "G" + g + " X" + x.ToString("f3") + " Y" +
y.ToString("f3") + " E" + e.ToString("f5");
else
lineatemp = "G" + g + " F" + f + " X" + x.ToString("f3") + " Y" +
y.ToString("f3") + " E" + e.ToString("f5");
}
}
sw.WriteLine(lineatemp);
xtemp = x; ytemp = y; ztemp = z; etemp = e;
}
z=Math.Round(z, 5);
if(z!=0)
zant = z;
xant = x; yant = y; eant = e;
}
}
else {
sw.WriteLine(cadena);
if(zact!=0)
zant = zact;
xant = xact; yant = yact; eant = eact;
}

35
 //lineatemp = lineatemp.Substring(0, lineatemp.Length - 1);
//sw.WriteLine(lineatemp);

g = 0; f = 0;
xact = 0; yact = 0; zact = 0;
}
zCambio = false;
}
}
sw.Close();
MessageBox.Show("Conversión terminada");
}
}
}

36
37