Scripted assembly sequences

Forum » Contraptor Forum / Questions / Issues » Scripted assembly sequences

Started by:

Albanetc
Date: 05 Feb 2011 07:46
Number of posts: 9

RSS: New posts

Unfold All Fold All More Options

Fold

Scripted assembly sequences

Albanetc 05 Feb 2011 07:46

As described in this thread, I had to make a few changes to the mini-CNC design for various reasons (easier adjustment etc). The assembly screenshots from the mini-CNC page (http://www.contraptor.org/mini-cnc#assembly) were all taken manually - quite a long process. Taking them again (and then, again) seems like something that should happen automatically. Previously, there was an idea of encoding assembly sequences in OpenSCAD: http://www.contraptor.org/forum/t-192150/suggestion:metric-version-please#post-733974

Sketchup has built-in Ruby interpreter, and I spent last couple of weeks figuring out how Sketchup could interpret an assembly sequence based on a Ruby script. Borrowing some methods from OpenSCAD, I think the script below looks readable. There are 2 classes - Component (which maps to Sketchup component instance) and Assembly (which maps to Sketchup group). The component names are also the file names in the Contraptor library (in Sketchup/Components) folder.

The following sequence:

Was produced from the following script (this is the base assembly of the mini-CNC):

def base
 
    base_front = Assembly.new("Base front")
    base_front << Component.new("perforated-angle-12").rotate!([0,0,-90]).translate!([0,0,-2])
    base_front << Component.new("perforated-angle-4").rotate!([0,90,-90]).translate!([1,0,0])
    base_front << Component.new("perforated-angle-4").rotate!([0,90,-90]).translate!([7,0,0])
    base_front << Component.new("perforated-angle-2").rotate!([90,0,180]).translate!([4,0,-2])
    base_front << Component.new("perforated-angle-2").rotate!([90,0,90]).translate!([8,0,-2])
    base_front << Component.new("perforated-angle-2").rotate!([90,0,90]).translate!([4,0,-1])
    base_front << Component.new("perforated-angle-2").rotate!([90,0,180]).translate!([8,0,-1])
    base_front << Component.new("perforated-angle-2").rotate!([0,-90,0]).translate!([4,-1,0])
    base_front << Component.new("perforated-angle-2").rotate!([0,0,0]).translate!([8,-1,0])
    base_front.screenshot
 
    base_back = Assembly.new("Base back")
    base_back << Component.new("perforated-angle-12").rotate!([0,180,-90])
    base_back << Component.new("perforated-angle-3").rotate!([0,-90,-90]).translate!([0,0,-2])
    base_back << Component.new("perforated-angle-3").rotate!([0,-90,-90]).translate!([9,0,-2])
    base_back << Component.new("perforated-angle-2").rotate!([90,0,-90]).translate!([3,0,-2])
    base_back << Component.new("perforated-angle-2").rotate!([90,0,0]).translate!([9,0,-2])
    base_back << Component.new("perforated-angle-2").rotate!([90,0,0]).translate!([4,0,-1])
    base_back << Component.new("perforated-angle-2").rotate!([90,0,-90]).translate!([8,0,-1])
    base_back.screenshot(camera = 1)
 
    base = Assembly.new("Base")        
    base << base_back.rotate!([0,0,180]).translate!([12,18,0])
    base << Component.new("perforated-angle-18").translate!([1,0,0])
    base << Component.new("perforated-angle-18").rotate!([0,-90,0]).translate!([11,0,0])
    base.screenshot
 
    base << base_front.rotate!([0,0,180]).translate!([12,0,0])
    base.screenshot    
 
end
 
# Create top level assembly
contraption = Assembly.new("mini-CNC")
 
# Set up extra cameras - they are shared among all instances of Assembly class
contraption.set_camera(1,[-30,-30,30])
contraption.set_camera(2,[30,0,0])
 
# Add subassemblies to the top level assembly
contraption << base
 
# Take a final screenshot using default camera
contraption.screenshot

The images are not in color yet, but it should be easy to add. Also, there are no fasteners - while they can be added via Component.new() - just like any other component in the library, this would probably make the script too bulky. Trying to figure out if there is a way to make them go to where they should be with minimum commands.

The plugin is attached (unzip in Plugins folder, restart Sketchup): http://www.contraptor.org/local--files/forum:thread/AIG.zip
The folder $SketchupHome\Components\Contraptor should contain SKP files with Contraptor components in order for plugin to work - alternatively, change component library path in assembly.rb and use arbitrary components.

Finally, there is no error handling and the code is a bit kludgy, but it works for me on Sketchup 8/WinXP

Last edited on 05 Feb 2011 08:00 by Albanetc Show more

Reply Options

Unfold Scripted assembly sequences by

Albanetc, 05 Feb 2011 07:46

Fold

Re: Scripted assembly sequences

arthurwolf 05 Feb 2011 11:30

Wow, great job !

Very readable, at least to the programmer mind …
How do you code this ( finding the vectors/rotations ) ? Trial/error or sheer mind power ?

For the fasteners :

component.connect(1,0).connect(2,1)

Would add a nut and bolt to the first hole, first side of the angle ( with enough spacing between the bolt head and the nut for two angles ), and second hole, second side of the angle … Thus connecting the angle with whatever is there.
Would be quite easy ( I think, never coded Sketchup plugins ), and mega-usefull …

Also suggestion : A plugin that writes the code from an already done sketchup file ( or at least helps ) , using groups to understand what is an Assembly.

Reply Options

Unfold Re: Scripted assembly sequences by

arthurwolf, 05 Feb 2011 11:30

Fold

Re: Scripted assembly sequences

Albanetc 07 Feb 2011 04:35

The reverse process is a great idea, thanks for the suggestion. This would generate an initial assembly file which can then be edited - I think this should save a lot of time needed to code it from scratch.

Transformations are coded with both trial/error and sheer mind power, mostly the former - it is pretty quick with the reload button :)

Just like in OpenSCAD, rotate!() progressively rotates the component around X, Y and Z axes - so I usually get the orientation right with a few reloads and then the translation is easy since everything is in the inch grid.

With the fasteners, I want to see if the code can automatically find the right positions for them based on predefined attachment points:

If this can work, the assembly script might look something like this:

    # create new assembly
    assembly = Assembly.new("sample assembly")
 
    # add components
    assembly << a12 = Component.new("angle-12").rotate!([]).translate!([])
    assembly << a4l = Component.new("angle-4").rotate!([]).translate!([])
    assembly << a2vlo = Component.new("angle-2").rotate!([]).translate!([])
    assembly << a2vli = Component.new("angle-2").rotate!([]).translate!([])
    assembly << a2hl = Component.new("angle-2").rotate!([]).translate!([])    
 
    # attach component a to component b
    assembly.attach(a12,a2vlo)
    assembly.attach(a4l,a2vlo)
    assembly.attach(a4l,a2vli)
    assembly.attach(a4l,a2hl)
    assembly.attach(a2vli,a2hl)

Reply Options

Unfold Re: Scripted assembly sequences by

Albanetc, 07 Feb 2011 04:35

Fold

Re: Scripted assembly sequences

arthurwolf 07 Feb 2011 19:03

Also, some ( most ? ) times, you'll just want to have bolts/nuts everywhere it is possible ( everywhere angles touch, looking at the mini-cnc design, it seems to work for most angle pairs ).

So then something like this maybe :

assembly.attach_all()
 
#Or
angle.attach(other_angle)

But that would require some quite hairy code …

Reply Options

Unfold Re: Scripted assembly sequences by

arthurwolf, 07 Feb 2011 19:03

Fold

Re: Scripted assembly sequences

Albanetc 14 Feb 2011 02:50

Minor update: colors are now supported when "Layer by color" is enabled (though you have to color layers manually, there is no easy way in the API to do that). The fasteners now can automatically find the right place and connect components/components and components/assemblies. This should also work on assemblies/assemblies but hasn't been tested. The way this works is that there are "interface" edges added to components on an invisible layer. Each interface has an origin point, normal and a thickness (edge length). The job of the script, given a pair of components, is to find a set of matching (i.e. opposite) normals and from there, a set of matching origins. Script now runs longer and Ruby console should be enabled to see that there is output.

There are a couple of bugs that need to be fixed. Now thinking about how to get the component to remember that it's already been attached at a certain point. This should help with joins where non-standard screws and specific screw orientation is important; these could be done first, everything else can be done automatically. There is the attach_all() method, but it currently only works on components/components within one assembly.

Code for the above sequence:

def base
 
    base_front = Assembly.new("Base front")
    base_front << Component.new("angle-12").rotate!([0,0,-90]).translate!([0,0,-2])
    base_front << Component.new("angle-4").rotate!([0,90,-90]).translate!([1,0,0])
    base_front << Component.new("angle-4").rotate!([0,90,-90]).translate!([7,0,0])
    base_front << Component.new("angle-2").rotate!([90,0,180]).translate!([4,0,-2])
    base_front << Component.new("angle-2").rotate!([90,0,90]).translate!([8,0,-2])
    base_front << Component.new("angle-2").rotate!([90,0,90]).translate!([4,0,-1])
    base_front << Component.new("angle-2").rotate!([90,0,180]).translate!([8,0,-1])
    base_front << Component.new("angle-2").rotate!([0,-90,0]).translate!([4,-1,0])
    base_front << Component.new("angle-2").rotate!([0,0,0]).translate!([8,-1,0])
    base_front.attach_all
    base_front.screenshot
 
    base_back = Assembly.new("Base back")
    base_back << Component.new("angle-12").rotate!([0,180,-90])
    base_back << Component.new("angle-3").rotate!([0,-90,-90]).translate!([0,0,-2])
    base_back << Component.new("angle-3").rotate!([0,-90,-90]).translate!([9,0,-2])
    base_back << Component.new("angle-2").rotate!([90,0,-90]).translate!([3,0,-2])
    base_back << Component.new("angle-2").rotate!([90,0,0]).translate!([9,0,-2])
    base_back << Component.new("angle-2").rotate!([90,0,0]).translate!([4,0,-1])
    base_back << Component.new("angle-2").rotate!([90,0,-90]).translate!([8,0,-1])
    base_back.attach_all
    base_back.screenshot(camera = 1)
 
    base = Assembly.new("Base")        
    base_front.rotate!([0,0,180]).translate!([12,0,0])
    base_back.rotate!([0,0,180]).translate!([12,18,0])
    base << a18l = Component.new("angle-18").translate!([1,0,0])
    base << a18r = Component.new("angle-18").rotate!([0,-90,0]).translate!([11,0,0])    
 
    base.attach(base_back,a18l)
    base.attach(base_back,a18r)
    base << base_back #bug: can't do <<(subassembly) prior to attach - it invalidates ComponentInstance handles of the subassembly
    base.screenshot
 
    base.attach(base_front,a18l)
    base.attach(base_front,a18r)
    base << base_front 
    base.screenshot    
 
end
 
# Create top level assembly
contraption = Assembly.new("mini-CNC")
 
# Set up extra cameras - they are shared among all instances of Assembly class
contraption.set_camera(1,[-30,-30,30])
contraption.set_camera(2,[30,0,0])
 
# Add subassemblies to the top level assembly
contraption << base

Last edited on 14 Feb 2011 02:57 by Albanetc Show more

Reply Options

Unfold Re: Scripted assembly sequences by

Albanetc, 14 Feb 2011 02:50

Fold

Re: Scripted assembly sequences

arthurwolf 14 Feb 2011 23:36

Wow ! Seeing attach_all working is very impressive !

On the critic side : I'm not a big fan of the colors … actually it's probably not the colors, but more the fact that all the component is painted with them … do you think there is a way to put the color only on a thin line on the side of the component, or in circles around the holes ? Will experiment with that next time I open Sketchup :) Not a very big deal anyway, would just be easier on the eye.
Edit : looking more at the pictures : Changing the colors a bit wouldn't hurt after all, they are very "basic" ( light blue and light green really hurt the eye ) … maybe using something like this or this or this ? ( my favorite is here but it's harder to use for more than 3/4 color shemes ). I understand the idea of the very basic colors is to be sure what size is an element just by looking at it's color … But that could be achieved with a smoother choice of colors …
Just saying :)

Last edited on 14 Feb 2011 23:49 by arthurwolf Show more

Reply Options

Unfold Re: Scripted assembly sequences by

arthurwolf, 14 Feb 2011 23:36

Fold

Re: Scripted assembly sequences

Albanetc 21 Feb 2011 03:17

Components are colored entirely as the colors come from layers. Coloring edges will probably be a lot more hairy. One unfortunate thing is that layer color is not accessible from Ruby API. It's basically a manual process to set them, so any palette with 9 distinct colors can be used. For now, I just reduced saturation on each to 50%, but there is probably a better palette.

Now the components "remember" that they have been attached at a certain point/interface. I had to add a new Interface class to support that. This enables a few things - you can attach a pair of components with non-default screw/nut, and then use attach_all to use default fasteners everywhere else. Attach() with nil fasteners marks interface as already attached. These cases can be seen on the first picture - two vertical angle-2s are not connected on the left and connected with shorter screw on the right. The attach_all now works on assemblies/components and assemblies/assemblies - though there are probably bugs.

def base
 
    base_front = Assembly.new("Base front")
    base_front << Component.new("angle-12").rotate!([0,0,-90]).translate!([0,0,-2])
    base_front << Component.new("angle-4").rotate!([0,90,-90]).translate!([1,0,0])
    base_front << Component.new("angle-4").rotate!([0,90,-90]).translate!([7,0,0])
    base_front << a2vro = Component.new("angle-2").rotate!([90,0,180]).translate!([4,0,-2])
    base_front << a2vlo = Component.new("angle-2").rotate!([90,0,90]).translate!([8,0,-2])
    base_front << a2vri = Component.new("angle-2").rotate!([90,0,90]).translate!([4,0,-1])
    base_front << a2vli = Component.new("angle-2").rotate!([90,0,180]).translate!([8,0,-1])
    base_front << Component.new("angle-2").rotate!([0,-90,0]).translate!([4,-1,0])
    base_front << Component.new("angle-2").rotate!([0,0,0]).translate!([8,-1,0])
    base_front.attach(a2vro,a2vri,"screw-1024-0375(ph)") # use screw other than default
    base_front.attach(a2vlo,a2vli,nil,nil) # mark as if already attached
    base_front.attach_all
    base_front.screenshot
 
    base_back = Assembly.new("Base back")
    base_back << Component.new("angle-12").rotate!([0,180,-90])
    base_back << Component.new("angle-3").rotate!([0,-90,-90]).translate!([0,0,-2])
    base_back << Component.new("angle-3").rotate!([0,-90,-90]).translate!([9,0,-2])
    base_back << Component.new("angle-2").rotate!([90,0,-90]).translate!([3,0,-2])
    base_back << Component.new("angle-2").rotate!([90,0,0]).translate!([9,0,-2])
    base_back << Component.new("angle-2").rotate!([90,0,0]).translate!([4,0,-1])
    base_back << Component.new("angle-2").rotate!([90,0,-90]).translate!([8,0,-1])
    base_back.attach_all
    base_back.screenshot(camera = 1)
 
    base = Assembly.new("Base")        
    base << base_back.rotate!([0,0,180]).translate!([12,18,0])
    base << a18l = Component.new("angle-18").translate!([1,0,0])
    base << a18r = Component.new("angle-18").rotate!([0,-90,0]).translate!([11,0,0])    
    base.attach_all
    base.screenshot
 
    base << base_front.rotate!([0,0,180]).translate!([12,0,0])
    base.attach_all
    base.screenshot    
 
end
 
# Create top level assembly
contraption = Assembly.new("mini-CNC")
 
# Set up extra cameras - they are shared among all instances of Assembly class
contraption.set_camera(1,[-30,-30,30])
contraption.set_camera(2,[30,0,0])
 
# Add subassemblies to the top level assembly
contraption << base

Reply Options

Unfold Re: Scripted assembly sequences by

Albanetc, 21 Feb 2011 03:17

Fold

Re: Scripted assembly sequences

Albanetc 27 Mar 2011 22:59

Update: I've been using small chunks of time to work on the assembly script for mini CNC, tweaking small things in the plugin code along the way. I still need to finish the (new) Z axis and I'm compiling the list of more significant todos (to be done later):

Add erase() method (currently remove())
Add true remove() method - remove Component from assembly but keep it at e.g. root level
Rewrite attach() method from Assembly.attach(entity_a,entity_b) to (Component|Assembly).attach(entity_to_attach), returning an assembly of correctly positioned fasteners
Add support for fastener defaults in Components (i.e. interface A uses fastener Q in orientation X by default)
Reverse process - taking a Sketchup file and writing it out into a script for later editing
Use multiple/arbitrary component libraries (e.g. "Contrapteur" or "SAE fasteners")
Text along with the screenshots
Add support for 2D attachment interface (line in addition to point)
Update Simon's BoM plugin to use the assembly tree
…

I'm not very happy about how verbose and procedural the script looks. On the other hand, I haven't really focused on optimizing it - finding loops and taking advantage of some symmetry in the assemblies.

Here is the sample output for X axis of the mini CNC:

Here is the script for the above screenshots:

$x_leadscrew_len = 14
 
def lr12
 
    # create linear rail assembly
    lr12 = Assembly.new("linear-rail-12-assembly")
    lr12 << a = Component.new("linear-rail-12")
    lr12 << b = Component.new("angle-12").translate!([0,0,0]).rotate!([0,90,0])
    lr12.attach(a,b,"linear-rail-fastener-set","nut-1024(hex)","010101101010")    
 
end
 
def xrail
 
    # create X rail assembly
    xrail = Assembly.new("X rail")
    xrail << lr12().translate!([0,0,4])
    xrail << lr12().rotate!([0,180,180]).translate!([0,12,0])
    xrail.screenshot
 
    xrail << a4l = Component.new("angle-4").rotate!([90,0,-90]).translate!([0,2,0])
    xrail.attach_all
    xrail.screenshot([-30,-30,10])
 
    xrail << a4r = Component.new("angle-4").rotate!([90,0,-180]).translate!([0,10,0])
    xrail.attach_all
    xrail.screenshot
 
    xrail << a3l = Component.new("angle-3").rotate!([0,0,0]).translate!([0,-1,2])
    xrail.attach(a3l,a4l)
    xrail.screenshot([30,-30,10])
 
    xrail << a2r = Component.new("angle-2").rotate!([0,0,0]).translate!([0,10,2])
    xrail.attach(a2r,a4r)
    xrail.screenshot
 
end
 
def xstage
 
    # create X stage assembly
    xstage = Assembly.new("X stage")
 
    # add linear bearing and show bearing alignment arrows
    xstage << bt = Component.new("linear-bearing-3.5")
    xstage << arr1 = Component.new("double-arrow").rotate!([90,0,0]).translate!([0.75,0.5,0.5])
    xstage << arr2 = Component.new("double-arrow").rotate!([90,0,0]).translate!([0.75,3,0.5])
    xstage.screenshot([2,6,3])
    xstage.remove(arr1)
    xstage.remove(arr2)
 
    # rotate bearing into right position and add a screw to the bottom
    bt.rotate!([0,90,0])
    dummy = Component.new("bar-1").rotate!([180,0,0]).translate!([1/4.0, 2+1/4.0, -1.5])
    xstage.attach(bt,dummy)
    xstage.remove(dummy)
 
    # add second bearing and add a screw to the bottom
    xstage << bb = Component.new("linear-bearing-3.5").rotate!([0,-90,0]).translate!([6.5,0,-1.5])
    dummy = Component.new("bar-1").rotate!([180,0,0]).translate!([5+1/4.0, 2+1/4.0, -1.5])
    xstage.attach(bb,dummy)
    xstage.remove(dummy)
 
    xstage.screenshot([30,30,10])
 
    xstage << a6r = Component.new("angle-6").rotate!([0,0,-90]).translate!([1/4.0, 3-1/4.0, 0])
    xstage << a6l = Component.new("angle-6").rotate!([0,-90,-90]).translate!([1/4.0, 1-1/4.0, 0])
    xstage.attach(bb,a6r,"screw-1024-0375(ph)")
    xstage.attach(bb,a6l,"screw-1024-0375(ph)")
    xstage.attach(bt,a6r,"screw-1024-0375(ph)")
    xstage.attach(bt,a6l,"screw-1024-0375(ph)")
    xstage.screenshot([10,0,30])
 
end
 
def leadnut(leadscrew_length = 14)
 
    leadnut = Assembly.new("Lead nut")
    leadnut << Component.new("coupling-nut-clamp").translate!([0,1/16.0,0])
    leadnut << Component.new("leadnut-mount").translate!([-1/4.0, 0, 0])
    leadnut << Component.new("screw-1024-05(ph)").rotate!([0,90,0]).translate!([-1/8.0,1/4.0,5/16.0])
    leadnut << Component.new("screw-1024-05(ph)").rotate!([0,90,0]).translate!([-1/8.0,1+1/4.0,5/16.0])
    leadnut << Component.new("nut-1024(hex)").rotate!([0,90,0]).translate!([-3/8.0,1/4.0,5/16.0])
    leadnut << Component.new("nut-1024(hex)").rotate!([0,90,0]).translate!([-3/8.0,1+1/4.0,5/16.0])
    leadnut << Component.new("screw-632-025").translate!([3/16.0, 1/4.0, 3/4.0])
    leadnut << Component.new("screw-632-025").translate!([3/16.0, 1+1/4.0, 3/4.0])
    leadnut.screenshot([-7,30,12])
 
    leadnut << ls = Component.new("threaded-rod-#{leadscrew_length}").translate!([1/4.0,-(leadscrew_length/2-1),3/16.0])
    leadnut << a18 = Component.new("angle-18").translate!([-1/2.0,-8-1/4.0,-3/16.0])
    leadnut << Component.new("nut-1024(hex)").rotate!([0,90,0]).translate!([-5/8.0,1/4.0,5/16.0])
    leadnut << Component.new("nut-1024(hex)").rotate!([0,90,0]).translate!([-5/8.0,1+1/4.0,5/16.0])
    leadnut.screenshot([0,10,5])
    leadnut << arr1 = Component.new("double-arrow").rotate!([0,0,90]).translate!([3/8.0,-5,3/8.0])
    leadnut << arr2 = Component.new("double-arrow").rotate!([0,0,90]).translate!([3/8.0,7,3/8.0])
    leadnut.screenshot([1,0,30],false)
 
    leadnut.remove(ls)
    leadnut.remove(a18)
    leadnut.remove(arr1)
    leadnut.remove(arr2)
 
end
 
def nwn
 
    nwn = Assembly.new("nut-washer-nut")
    nwn << Component.new("nut-025(hex)")
    nwn << Component.new("washer-025(spring)").translate!([0,0,3/16.0])
    nwn << Component.new("nut-025(hex)").translate!([0,0,1/4.0])
 
end
 
def motor
 
    motor = Assembly.new("motor assembly")
    motor << Component.new("motor-NEMA23").rotate!([0,-90,-90]).translate!([0.5,-1/8.0,0.5])
    motor << Component.new("coupling-jaw-hub-025").rotate!([-90,90,0]).translate!([0.5,13/16.0,0.5])
    motor << Component.new("coupling-jaw-spider").rotate!([-90,0,0]).translate!([0.5,17/16.0,0.5])
 
    motor << Component.new("spacer-10(nylon)").rotate!([-90,0,0]).translate!([-7/16.0,-3/16.0,-7/16.0])
    motor << Component.new("spacer-10(nylon)").rotate!([-90,0,0]).translate!([1+7/16.0,-3/16.0,-7/16.0])
    motor << Component.new("screw-1024-075(ph)").rotate!([90,0,0]).translate!([-7/16.0,-3/8.0,-7/16.0])
    motor << Component.new("screw-1024-075(ph)").rotate!([90,0,0]).translate!([1+7/16.0,-3/8.0,-7/16.0])
    motor << Component.new("nut-1024(hex)").rotate!([90,90,0]).translate!([-7/16.0,1/4.0,-7/16.0])
    motor << Component.new("nut-1024(hex)").rotate!([90,90,0]).translate!([1+7/16.0,1/4.0,-7/16.0])
 
end
 
def shaft_mount
 
    sm = Assembly.new("shaft mount")
    sm << Component.new("shaft-mount")
 
end
 
def flywheel
 
    flywheel = Assembly.new("flywheel")
    flywheel << Component.new("angle-3")
 
    flywheel << Component.new("screw-1024-1(ph)").rotate!([0,-90,0]).translate!([0,0.5,0.5])
    (0..3).each {|i| flywheel << Component.new("nut-025(square)").rotate!([0,-90,0]).translate!([(3*i+5)/16.0, 0.5, 0.5])}
    flywheel << Component.new("nut-1024(hex)").rotate!([0,-90,0]).translate!([1,0.5,0.5])
 
    flywheel << Component.new("screw-1024-1(ph)").rotate!([0,-90,0]).translate!([0,2.5,0.5])
    (0..3).each {|i| flywheel << Component.new("nut-025(square)").rotate!([0,-90,0]).translate!([(3*i+5)/16.0, 2.5, 0.5])}
    flywheel << Component.new("nut-1024(hex)").rotate!([0,-90,0]).translate!([1,2.5,0.5])
 
end
 
def xaxis
 
    # create X axis, add bare X rail and bare X stage, show X stage alignment arrow
    xaxis = Assembly.new("X axis")
    xaxis << xrail = xrail()
    xaxis << xstage = xstage().rotate!([0,90,0]).translate!([1+1/4.0, 4+1/4.0, 5+1/4.0])
    xstage << arr0 = Component.new("double-arrow").rotate!([0,0,90]).translate!([0.5,3,-0.125])
    xaxis.screenshot
    xstage.remove(arr0)
 
    # lay X axis down
    xaxis.rotate!([0,-90,0])
 
    # add shaft mounts
    xrail << sml = shaft_mount.rotate!([0,180,90]).translate!([1,2,2])
    xrail.attach(sml,xrail,"screw-1024-0375(ph)")
    xrail << smr = shaft_mount.rotate!([0,180,-90]).translate!([0,11,2])
    xrail.attach(smr,xrail,"screw-1024-0375(ph)")
    xaxis.screenshot([2,20,10])
    xaxis.screenshot([2,-20,10])
 
    # add leadnut with leadscrew
    xstage << leadnut($x_leadscrew_len).rotate!([0,90,180]).translate!([4+1/16.0,2.5,-3/8.0])    
    xaxis << Component.new("threaded-rod-#{$x_leadscrew_len}").rotate!([0,0,0]).translate!([0.5-1/8.0,1/8.0,1.5-1/8.0])
 
    # show alignment arrows, in perspective and ortho
    xaxis << arr1 = Component.new("double-arrow").rotate!([90,90,0]).translate!([0.5,2,1.5])
    xaxis << arr2 = Component.new("double-arrow").rotate!([90,90,0]).translate!([0.5,11+1/8.0,1.5])
    xaxis << arr3 = Component.new("double-arrow").rotate!([90,0,0]).translate!([0.5,7,1.5])
    xaxis.screenshot([5,20,20])
    xaxis.screenshot([0,30,0],false)
    xaxis.remove(arr1)
    xaxis.remove(arr2)
    xaxis.remove(arr3)
 
    # add bearings to shaft mounts
    sml << Component.new("bearing-R188-2RS").rotate!([0,90,0]).translate!([1/8.0,0.5,0.5])
    smr << Component.new("bearing-R188-2RS").rotate!([0,90,0]).translate!([1/8.0,0.5,0.5])
    xaxis << arrc = Component.new("circular-arrow").rotate!([90,0,0]).translate!([0.5,12.5,1.5])
    xaxis.screenshot([3,20,4])
 
    # show motor with mount and hub+spider, then remove mount
    motor = motor()
    motor << mm = Component.new("motor-mount-nema23").rotate!([0,180,-90]).translate!([-3/4.0,0,-1/8.0])
    motor.screenshot([5,3,0])
    motor.remove(mm)
 
    # add motor + mount, show lengthwise leadscrew alignment arrow, add nut-washer-nut on motor side
    xaxis << motor.rotate!([0,180,0]).translate!([1,-1-1/4.0,2])
    xaxis << mm = Component.new("motor-mount-nema23").rotate!([0,0,90]).translate!([1+3/4.0,-1-1/4.0,2+1/8.0])    
    xaxis << arr4 = Component.new("double-arrow").rotate!([0,90,0]).translate!([0.5,2,1.5])
    xaxis << nwn1 = nwn.rotate!([-90,0,0]).translate!([0.5,1.25,1.5])
    xaxis.screenshot([5,3,7],true,mm)
    xaxis.remove(arr4)
 
    # add nut-washer-nut on flywheel side
    xaxis << nwn2 = nwn.rotate!([-90,0,0]).translate!([0.5,11+5/16.0,1.5])
    xaxis.screenshot([-1,16,5],true,smr)
    xaxis.remove(arrc)
 
    # remove motor and attach motor mount
    xaxis.remove(motor)    
    xaxis.attach(xrail,mm)
    xrail << a1l = Component.new("angle-1").rotate!([0,-90,0]).translate!([0,-1,2])
    xrail.attach(xrail,a1l)
    xrail.attach(mm,a1l)
    xaxis << cpl = Component.new("coupling-jaw-hub-025").rotate!([90,90,0]).translate!([0.5,0.75,1.5])
    xaxis.screenshot([3,-3,4],true,mm)
 
    # move leadscrew coupling hub, reinstall motor
    cpl.translate!([0,-3/8.0,0])
    xaxis << motor = motor().rotate!([0,180,0]).translate!([1,-1-1/4.0,2])
    xaxis.screenshot([5,0,7],true,mm)
 
    # stand X axis up, add rear brace to X stage
    xaxis.rotate!([0,90,0])
    xstage << Component.new("angle-6").rotate!([180,0,-90]).translate!([6+1/4.0, 2+1/4.0,-1.5])
    xaxis.screenshot([-30,-30,10])
 
    # add flywheel
    flywheel = flywheel()
    flywheel.screenshot
 
    xaxis << flywheel.rotate!([0,0,90]).translate!([2,13,1])
    xaxis << Component.new("nut-025(hex)").rotate!([90,0,0]).translate!([0.5,13,1.5])
    xaxis << Component.new("nut-025(hex)").rotate!([90,0,0]).translate!([0.5,13+5/16.0,1.5])
    xaxis.screenshot([6,16,5],true)
 
end
 
xaxis()

Reply Options

Unfold Re: Scripted assembly sequences by

Albanetc, 27 Mar 2011 22:59

Fold

Re: Scripted assembly sequences

Albanetc 18 Apr 2011 05:51

Another update. Added a simple capability to output assembly script for currently selected components to console. Currently works correctly for top level objects only.

The video shows opening the script file, generation of screenshots as well as assembly script output.

Reply Options

Unfold Re: Scripted assembly sequences by

Albanetc, 18 Apr 2011 05:51

New Post