Show your print

[DragonSan26]

hey i wanted to start this discution to show out our creation on the github

[DragonSan26]

here is mine a blade for a lightsaber with a wall thickness of 1mm and printed in vase mode
the code for the blade (you just have to change the start radius and end radius to match your need
python code for test lightsaber blades.txt
and here is for the tip of the blade with a parabolic helix (same as before you have to change the start radius and end radius )
code blade part 5 tip.txt

[AndyGlx]

Nice idea thanks!

Quick note to make it more accessible for people:

how to preview a python file in colab...

create a new colab notebook with two code cells:
- first cell: !pip install fullcontrol --quiet
- second cell: [the python-file code]
- screenshot below shows gcode saved in folder access on left hand side

It would also be best to share an image of the part (either printed or the FullControl preview)

Here's the FullControl preview of your part

FYI, there is a relevant gist for a spherical top with automatically varying layer height to maintain constant separation between lines here:
https://colab.research.google.com/gist/fullcontrol-xyz/a4271e8aa048cec108e1e236ce3ddf8e/sphere.ipynb

Obvious hone in settings on a much smaller saber (or just a dome)! It might take a few iterations to get a perfect top of the sphere.

[fullcontrol-xyz]

Did you mean to add photos?

Sure thanks i did end up using visual studio code during debugging and here are the printed pieces...

Sounds cool with next steps. FYI, dome will need relatively narrow extrusion (not much wider than 'layer height').

[DragonSan26]

Cant it work with a wide extrusion and very slow movement?

[DragonSan26]

But ok i'll try with smaller width

[fullcontrol-xyz]

Sorry I didn't write 'dome' correctly in my previous comment. Edited it now.

The problem with wider extrusion is that at the top of the dome, the extruded lines are stacked sideways instead of upwards, which means conventional 'wider' changes to be 'taller'. Things can get messy if you try to print lines that are taller than they are wide

[DragonSan26]

Ok 👍

[DragonSan26]

Here are the pictures

[DragonSan26]

And it doesn't seem to work

[DragonSan26]

No ok it just didn't want to show itself

[fullcontrol-xyz]

Yep, can see it. Looks neat 👍

[DragonSan26]

Yep but still not strong enough

[DragonSan26]

Ps it's printed in meta pla ( from sunlu)

[DragonSan26]

I started trying to make the z zig zag using polar coordinates and i was wondering if it was possible to use radiant instead angle fraction?

[fullcontrol-xyz]

Polar coordinates have no Z component, so you control z however you like based on the Z value of centre point. Not sure exactly which functions you're referring to with regards to radiant and angle fraction. Neither of those are particularly common terms

[DragonSan26]

I used "fractional design engine demo" for the base to try and make it and the variable for the angle is set-up from 0 to one but when i looked at polar to point it said that it's expressed as radiant ( pi and 2pi with the trigonometry circle) and since i'm most used to that one i thought that maybe there was a way to directly use it instead

[fullcontrol-xyz]

Ah gotcha, I forgot about that!

If that design engine is useful, I may create a more versatile version of it

[fullcontrol-xyz]

For a polar Z wave, I think the easiest method is probably to create a list of points for a circle and then offset the Z component of every alternate point..?

[DragonSan26]

For every point i mean

[fullcontrol-xyz]

You could also do a 'postprocess' of a non-zigzag toolpath or of every layer of it with something like:

for i in range(1, len(steps), 2):
    steps[i].z += 0.6

This will modify the z attribute of points 1, 3, 5, etc.,.

[DragonSan26]

I ended up making 3 lists of x y and z and then add them to the points in steps
For now i have a "layer"
Bonus it is zig zag and continuous ( except for the first small bits to support the zig zag and the last small bits to close at the top )
P.S. I really need to switch to another pc because it makes it crash

[DragonSan26]

ok the "layer" code worked



it isn't ready to be printed but still interresting
here is the python code made in vs code

import fullcontrol as fc
from math import tau
from math import cos
from math import sin
from math import pi

steps = []
block0 = []
block1 = []
block2 = []
x = []
y = []
z = []
a_list = []
b_list = []

a = 0
b = 0
angle = 0
rayon = 0
rayon_start = 7
rayon_end = 6
rayon_middle = (rayon_start + rayon_end)/2

centre_x = 10
centre_y = 10
centre_Z = 0
segments = 5
i = 0
j = 0
k = 0
l = 0
m = 0

while k <= segments:
rayon =rayon_middle
sections = (2pirayon) // 1
sections = 2sections
section_lenght = (2pi * rayon) /sections
angle_sections = section_lenght / rayon
angle = angle + angle_sections / segments
b = sin(angle) * rayon
x.append(b + centre_x)
a = cos(angle) * rayon
y.append(a + centre_y)
z.append(0.4)
k = k +1
angle = angle - angle_sections / segments

while l <= segments:
rayon =rayon_middle + l*(rayon_start - rayon_middle)/segments
sections = (2pirayon) // 1
section_lenght = (2*pi * rayon) /sections
angle_sections = section_lenght / rayon
angle = angle + angle_sections / segments
b = sin(angle) * rayon
x.append(b + centre_x)
a = cos(angle) * rayon
y.append(a + centre_y)
z.append(0.4 + (0.2 - 0.4)*l/ segments)
l = l+1
angle = angle - angle_sections / segments
angle = angle - angle_sections / segments

while j <= 8:
while i <= segments:
rayon = rayon_start + i*(rayon_end - rayon_start)/segments
sections = (2pirayon) // 2
section_lenght = (2*pi * rayon) /sections
angle_sections = section_lenght / rayon
angle = angle + angle_sections / segments
b = sin(angle) * rayon
x.append(b + centre_x)
a = cos(angle) * rayon
y.append(a + centre_y)
z.append(0.2 + (0.6 - 0.2) * i /segments)

    i = i + 1
angle = angle - angle_sections / segments
i = 0
while i <= segments:
    rayon = rayon_end + i*(rayon_start - rayon_end)/segments
    sections = (2*pi*rayon) // 2
    section_lenght = (2*pi * rayon) /sections
    angle_sections = section_lenght / rayon 
    angle = angle + angle_sections / segments
    b = sin(angle) * rayon
    x.append(b + centre_x)
    a = cos(angle) * rayon
    y.append(a + centre_y)
    z.append(0.6+ (0.2 - 0.6) * i /segments) 
    i = i + 1
angle = angle - angle_sections / segments
i = 0
j = j+1

i=0
while i <= segments:
rayon = rayon_start + i*(rayon_end - rayon_start)/segments
sections = (2pirayon) // 2
section_lenght = (2*pi * rayon) /sections
angle_sections = section_lenght / rayon
angle = angle + angle_sections / segments
b = sin(angle) * rayon
x.append(b + centre_x)
a = cos(angle) * rayon
y.append(a + centre_y)
z.append(0.2 + (0.6 - 0.2) * i /segments)
i = i+1

i = 0
while i <= len(x)-1:
block1.append(fc.Point(x = x[i], y = y[i], z = z[i]))

i = i + 1

block0.append(fc.Extruder(on=True))
block2.append(fc.Extruder(on=False))
steps = block0 + block1 + block2
fc.transform(steps, 'plot', fc.PlotControls(style='line'))

[fullcontrol-xyz]

Very cool path yeh!

[DragonSan26]

The code is up and working i'm trying to push the limit in terms of speed but the results are very promising

[DragonSan26]

I managed up to 350 mm/s with my j1 max and with decent quality

[DragonSan26]

*K1 max

[DragonSan26]

i've made the code parametric (kind of ):
here is a creenshot of the prewiew with a radius of 30mm to 20mm and a height of 10mm
i used vs code to make it but i can't seem to be able to upload the code so here is it

import fullcontrol as fc
from math import tau
from math import cos
from math import sin
from math import pi
from math import remainder

steps = []
block0 = []
block1 = []
block2 = []
x = []
x_debut = []
y = []
y_debut = []
z = []
z_debut = []
a_list = []
b_list = []
height = 0
a = 0
b = 0
angle = 0
rayon = 0
layer = int(input("number of layers(layer height is 0.1mm):"))
rayon_base = int(input("radius of the base of the cylinder(mm):"))
rayon_top = int(input("radius of the top of the cylinder(mm):"))
rayon_change = (rayon_top - rayon_base)/ layer
rayon_start = rayon_base
rayon_end = rayon_base + rayon_change
sections=(2pirayon_base) // 1
doubles_sections = (2pirayon_base) // 2
reste = remainder((2*pi * rayon) , 2)
angle_a_2_pi_pres = 1
z_height_final = 0
layer_height = 0.1

centre_x = 210
centre_y = 150
centre_Z = 0
segments = 5
i = 0
j = 0
k = 0
l = 0
m = 0
trop_petit_angle = 0
block1.append(fc.Extruder(on=True))
while m <= layer - 1:
if trop_petit_angle == 1:
fc.Extruder(on=True)

height = height + 0.1

rayon_start = rayon_start + rayon_change
rayon_end = rayon_end + rayon_change
rayon_middle = (rayon_start + rayon_end)/2
sections = sections * 1


sections = sections / 1

while j <= doubles_sections-1:
    while i <= segments:
        rayon = rayon_start + i*(rayon_end - rayon_start)/segments
        #sections = (2*pi*rayon) // 2
        
        section_lenght = (2*pi * rayon) /sections
        angle_sections = section_lenght / rayon 
        angle = angle + angle_sections / segments
        b = sin(angle) * rayon
        x.append(b + centre_x)
        a = cos(angle) * rayon
        y.append(a + centre_y)
        z.append(height + 0.1 + (0.3 - 0.1) * i /segments) 
      


        i = i + 1
    angle = angle - angle_sections / segments
    i = 0
    while i <= segments:
        rayon = rayon_end + i*(rayon_start - rayon_end)/segments
        #sections = (2*pi*rayon) // 2
        section_lenght = (2*pi * rayon) /sections
        
        angle_sections = section_lenght / rayon 
        angle = angle + angle_sections / segments
        
        b = sin(angle) * rayon
        x.append(b + centre_x)
        a = cos(angle) * rayon
        y.append(a + centre_y)
        z.append(height + 0.3+ (0.1 - 0.3) * i /segments) 
        z_height_final = height + 0.3+ (0.1 - 0.3) * i /segments
     
        i = i + 1
    angle = angle - angle_sections / segments
    i = 0
    j = j+1
i=0

angle_section_final = angle

if (2*pi )- angle_section_final  < 0.001:
    trop_petit_angle = 1
    fc.Extruder(on=False)

else:
    trop_petit_angle = 0
    while i <= segments:
        rayon = rayon_start + i*(rayon_end - rayon_start)/segments
        #sections = (2*pi*rayon) // 2
        
        section_lenght = ((2*pi )- angle_section_final )* rayon
        
        angle_sections = section_lenght / rayon 
        angle = angle + angle_sections / segments
        b = sin(angle) * rayon
        x.append(b + centre_x)
        a = cos(angle) * rayon
        y.append(a + centre_y)
        z.append(height + 0.1 + (0.3 - 0.1) * i /(2 *segments)) 
        


        i = i + 1
  

angle = 0
sections = sections * 1
m=m+1
i = 0 
j = 0
k = 0
l = 0 

block2.append(fc.Extruder(on=False))
while l<= doubles_sections-1:
while i <= segments:
rayon = rayon_start + i*(rayon_end - rayon_start)/segments
#sections = (2pirayon) // 2

        section_lenght = (2*pi * rayon) /sections
        angle_sections = section_lenght / rayon 
        angle = angle + angle_sections / segments
        b = sin(angle) * rayon
        x_debut.append(b + centre_x)
        a = cos(angle) * rayon
        y_debut.append(a + centre_y)
        z_debut.append( (layer*0.1+0.35) )
        
        block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))

        i = i + 1
angle = angle - angle_sections / segments

i = 0
while i <= segments:
        rayon = rayon_end + i*(rayon_start - rayon_end)/segments
        #sections = (2*pi*rayon) // 2
        section_lenght = (2*pi * rayon) /sections
        
        angle_sections = section_lenght / rayon 
        angle = angle + angle_sections / segments
        
        b = sin(angle) * rayon
        x_debut.append(b + centre_x)
        a = cos(angle) * rayon
        y_debut.append(a + centre_y)
        z_debut.append((layer*0.1+0.35) )
        block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
        i = i + 1
block2.append(fc.Extruder(on=True))
block2.append(fc.PlotAnnotation(label=''))
block2.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
block2.append(fc.ManualGcode(text="G4 P100"))
block2.append(fc.Extruder(on=False))

angle = angle - angle_sections / segments
i = 0
l = l + 1

rayon_start = rayon_base
rayon_end = rayon_base + rayon_change

block0.append(fc.Buildplate(temp=input("temperature of the buildplate:"), wait=True))
block0.append(fc.Extruder(units='mm3',dia_feed=1.75,))
block0.append(fc.Printer(print_speed=input("printing speed:"),travel_speed=input("travel speed:")))
block0.append(fc.Hotend(temp=input("temperature of the hotend"), wait=True))
block0.append(fc.Extruder(on=False))
while k <= doubles_sections-1:
while i <= segments:
rayon = rayon_start + i*(rayon_end - rayon_start)/segments
#sections = (2pirayon) // 2

        section_lenght = (2*pi * rayon) /sections
        angle_sections = section_lenght / rayon 
        angle = angle + angle_sections / segments
        b = sin(angle) * rayon
        x_debut.append(b + centre_x)
        a = cos(angle) * rayon
        y_debut.append(a + centre_y)
        z_debut.append( 0.2 ) 
        
        block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))

        i = i + 1
angle = angle - angle_sections / segments
block0.append(fc.Extruder(on=True))
block0.append(fc.PlotAnnotation(label=''))
block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
block0.append(fc.ManualGcode(text="G4 P100"))
block0.append(fc.Extruder(on=False))
i = 0
while i <= segments:
        rayon = rayon_end + i*(rayon_start - rayon_end)/segments
        #sections = (2*pi*rayon) // 2
        section_lenght = (2*pi * rayon) /sections
        
        angle_sections = section_lenght / rayon 
        angle = angle + angle_sections / segments
        
        b = sin(angle) * rayon
        x_debut.append(b + centre_x)
        a = cos(angle) * rayon
        y_debut.append(a + centre_y)
        z_debut.append(0.2) 
        block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
        i = i + 1
angle = angle - angle_sections / segments
i = 0
k = k + 1

i = 0
while i <= len(x)-1:
block1.append(fc.Point(x = x[i], y = y[i], z = z[i]))

i = i + 1

#block0.append(fc.Extruder(on=True))

block2.append(fc.Extruder(on=False))
block2.append(fc.Buildplate(temp=0, wait=True))

block2.append(fc.Hotend(temp=0, wait=True))
block2.append(fc.Extruder(on=False))
block2.append(fc.Point(z = layer_height * layer + 50))
steps = block0 + block1 + block2
fc.transform(steps, 'plot', fc.PlotControls(style='line'))
fc.transform(steps, 'gcode',fc.GcodeControls(save_as="gcode test blade 4"))

[DragonSan26]

if someone know how to make it all be in the "bubble " you cant copy that would be great test

[DragonSan26]

nevermind it worked

[fullcontrol-xyz]

Great, I love parametric design! What is the part for?

[DragonSan26]

To make a tube for the blade of the lightsaber but it can be use to make any tube

[DragonSan26]

import fullcontrol as fc
from math import tau
from math import cos
from math import sin 
from math import pi
from math import remainder

steps = []
block0 = []
block1 = []
block2 = []
x = []
x_debut = []
y = []
y_debut = []
z = []
z_debut = []
a_list = []
b_list = []
height = 0
a = 0
b = 0
angle = 0
rayon  = 0
layer = int(input("number of layers(layer height is 0.1mm):"))
rayon_base = int(input("radius of the base of the cylinder(mm):"))
rayon_top = int(input("radius of the top of the cylinder(mm):"))
rayon_change = (rayon_top - rayon_base)/ layer
rayon_start = rayon_base
rayon_end = rayon_base + rayon_change
sections=(2*pi*rayon_base) // 1
doubles_sections = (2*pi*rayon_base) // 2
reste = remainder((2*pi * rayon) , 2)
angle_a_2_pi_pres = 1
z_height_final = 0
layer_height = 0.1





centre_x = 210
centre_y = 150
centre_Z = 0
segments = 5
i = 0
j = 0
k = 0
l = 0
m = 0
trop_petit_angle = 0
block1.append(fc.Extruder(on=True))
while m <= layer - 1:
    if trop_petit_angle == 1:
        fc.Extruder(on=True)

    height = height + 0.1
    
    rayon_start = rayon_start + rayon_change
    rayon_end = rayon_end + rayon_change
    rayon_middle = (rayon_start + rayon_end)/2
    sections = sections * 1
    
   
    sections = sections / 1
    
    while j <= doubles_sections-1:
        while i <= segments:
            rayon = rayon_start + i*(rayon_end - rayon_start)/segments
            #sections = (2*pi*rayon) // 2
            
            section_lenght = (2*pi * rayon) /sections
            angle_sections = section_lenght / rayon 
            angle = angle + angle_sections / segments
            b = sin(angle) * rayon
            x.append(b + centre_x)
            a = cos(angle) * rayon
            y.append(a + centre_y)
            z.append(height + 0.1 + (0.3 - 0.1) * i /segments) 
          

    
            i = i + 1
        angle = angle - angle_sections / segments
        i = 0
        while i <= segments:
            rayon = rayon_end + i*(rayon_start - rayon_end)/segments
            #sections = (2*pi*rayon) // 2
            section_lenght = (2*pi * rayon) /sections
            
            angle_sections = section_lenght / rayon 
            angle = angle + angle_sections / segments
            
            b = sin(angle) * rayon
            x.append(b + centre_x)
            a = cos(angle) * rayon
            y.append(a + centre_y)
            z.append(height + 0.3+ (0.1 - 0.3) * i /segments) 
            z_height_final = height + 0.3+ (0.1 - 0.3) * i /segments
         
            i = i + 1
        angle = angle - angle_sections / segments
        i = 0
        j = j+1
    i=0
    
    angle_section_final = angle
    
    if (2*pi )- angle_section_final  < 0.001:
        trop_petit_angle = 1
        fc.Extruder(on=False)

    else:
        trop_petit_angle = 0
        while i <= segments:
            rayon = rayon_start + i*(rayon_end - rayon_start)/segments
            #sections = (2*pi*rayon) // 2
            
            section_lenght = ((2*pi )- angle_section_final )* rayon
            
            angle_sections = section_lenght / rayon 
            angle = angle + angle_sections / segments
            b = sin(angle) * rayon
            x.append(b + centre_x)
            a = cos(angle) * rayon
            y.append(a + centre_y)
            z.append(height + 0.1 + (0.3 - 0.1) * i /(2 *segments)) 
            

    
            i = i + 1
      
   
    angle = 0
    sections = sections * 1
    m=m+1
    i = 0 
    j = 0
    k = 0
    l = 0 
block2.append(fc.Extruder(on=False)) 
while l<= doubles_sections-1:
    while i <= segments:
            rayon = rayon_start + i*(rayon_end - rayon_start)/segments
            #sections = (2*pi*rayon) // 2
            
            section_lenght = (2*pi * rayon) /sections
            angle_sections = section_lenght / rayon 
            angle = angle + angle_sections / segments
            b = sin(angle) * rayon
            x_debut.append(b + centre_x)
            a = cos(angle) * rayon
            y_debut.append(a + centre_y)
            z_debut.append( (layer*0.1+0.35) )
            
            block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
    
            i = i + 1
    angle = angle - angle_sections / segments
    
    i = 0
    while i <= segments:
            rayon = rayon_end + i*(rayon_start - rayon_end)/segments
            #sections = (2*pi*rayon) // 2
            section_lenght = (2*pi * rayon) /sections
            
            angle_sections = section_lenght / rayon 
            angle = angle + angle_sections / segments
            
            b = sin(angle) * rayon
            x_debut.append(b + centre_x)
            a = cos(angle) * rayon
            y_debut.append(a + centre_y)
            z_debut.append((layer*0.1+0.35) )
            block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
            i = i + 1
    block2.append(fc.Extruder(on=True))
    block2.append(fc.PlotAnnotation(label=''))
    block2.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
    block2.append(fc.ManualGcode(text="G4 P100"))
    block2.append(fc.Extruder(on=False))

    angle = angle - angle_sections / segments
    i = 0
    l = l + 1
rayon_start = rayon_base
rayon_end = rayon_base + rayon_change



block0.append(fc.Buildplate(temp=input("temperature of the buildplate:"), wait=True))
block0.append(fc.Extruder(units='mm3',dia_feed=1.75,))
block0.append(fc.Printer(print_speed=input("printing speed:"),travel_speed=input("travel speed:")))
block0.append(fc.Hotend(temp=input("temperature of the hotend"), wait=True))
block0.append(fc.Extruder(on=False))   
while k <= doubles_sections-1:
    while i <= segments:
            rayon = rayon_start + i*(rayon_end - rayon_start)/segments
            #sections = (2*pi*rayon) // 2
            
            section_lenght = (2*pi * rayon) /sections
            angle_sections = section_lenght / rayon 
            angle = angle + angle_sections / segments
            b = sin(angle) * rayon
            x_debut.append(b + centre_x)
            a = cos(angle) * rayon
            y_debut.append(a + centre_y)
            z_debut.append( 0.2 ) 
            
            block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
    
            i = i + 1
    angle = angle - angle_sections / segments
    block0.append(fc.Extruder(on=True))
    block0.append(fc.PlotAnnotation(label=''))
    block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
    block0.append(fc.ManualGcode(text="G4 P100"))
    block0.append(fc.Extruder(on=False))
    i = 0
    while i <= segments:
            rayon = rayon_end + i*(rayon_start - rayon_end)/segments
            #sections = (2*pi*rayon) // 2
            section_lenght = (2*pi * rayon) /sections
            
            angle_sections = section_lenght / rayon 
            angle = angle + angle_sections / segments
            
            b = sin(angle) * rayon
            x_debut.append(b + centre_x)
            a = cos(angle) * rayon
            y_debut.append(a + centre_y)
            z_debut.append(0.2) 
            block0.append(fc.Point(x=x_debut[-1],y=y_debut[-1],z=z_debut[-1]))
            i = i + 1
    angle = angle - angle_sections / segments
    i = 0
    k = k + 1






i = 0
while i <= len(x)-1:
    block1.append(fc.Point(x = x[i], y = y[i], z = z[i]))

    i = i + 1

#block0.append(fc.Extruder(on=True))

block2.append(fc.Extruder(on=False))
block2.append(fc.Buildplate(temp=0, wait=True))


block2.append(fc.Hotend(temp=0, wait=True))
block2.append(fc.Extruder(on=False)) 
block2.append(fc.Point(z = layer_height * layer + 50))  
steps = block0 + block1 + block2
fc.transform(steps, 'plot', fc.PlotControls(style='line'))
fc.transform(steps, 'gcode',fc.GcodeControls(save_as="gcode test blade 4"))

[DragonSan26]

I worked on making better base triangles ( higher) wich reach up to 5 mm tall for 10 mm wide and here's a picture of the last test piece wich is five of such triangles printed next to one another ( to make 5 mm thick walls for another project)

[DragonSan26]

For the segmentation it's already done as it was needed for a smooth curve and I'm gonna try and see the results with the bigger nozzle, if I still get issues I will change the design

[DragonSan26]

I did the test with the 0.8 mm nozzle and it's going really well, just underestimated the height so there's a small collision between the top of the second "layer" spike and the head of the printer

[DragonSan26]

here is a prewiew

[DragonSan26]

I divided it in two parts and it worked

[DragonSan26]

Here is it