CNC Robotic Light Painting

In this tutorial we will be using Tobor to create some light paintings

Overview

This tutorial is separated into 3 parts.

• Part 1: Creating the Spiral Generator
• Part 2: Program Tobor and the NeoBoard
• Part 3: Create more fun paintings
• Part 4: Take the Picture!

Part 1: Creating The Spiral Generator

The first thing we've created was a small program that let's us create robot code that will draw a spiral

The program comes fitted with a 3D viewer that shows 3 states of the program.

• Purple Spiral: The original spiral created by the codeblock
• Green Spiral: The spiral that will actually be drawn by Tobor and is translated by the CNCTranslator Parameter
• Yellow Spiral: This is the final output of the program and is the robot code that will draw the actual spiral. This code has the scara kinematics already applied by the ScaraKinematics Parameter

The code above was created in the Floe IDE and will create a spiral and there are 3 basic sections.

The first section that contains 3 GuiSliders (slider elements that will show up in the running program. The labels for each slider will be the same name as they have in Floe. These sliders control the height, width and number of revolutions of the spiral.

This section also contains a codeblock that creates the actual spiral. This codeblock returns a string in the form of json lines. Json lines is the format Tobor and the GuiCodeEditors accept.

def function(event: int, height, width, revs):  # This line is auto-generated. Do Not Change.
    # add your code here
    import math, json

    def generate_spiral_cone(height, width, revolutions):
        """
        Generate (x, y, z) points forming a spiral on a cone.

        Args:
            height (float): Height of the cone in mm.
            width (float): Diameter of the base of the cone in mm.
            revolutions (int): Number of spiral revolutions up the cone.

        Returns:
            generator: List of machine code strings representing the spiral curve.
        """
        # Radius of the cone's base
        radius = width / 2

        # Calculate the total curve length
        slant_height = math.sqrt(height**2 + radius**2)
        curve_length = slant_height * revolutions
        num_points = int(curve_length)  # 1mm spacing

        # Calculate angle step and vertical step per point
        theta_step = 2 * math.pi * revolutions / num_points
        z_step = height / num_points

        # Generate points
        for i in range(num_points):
            theta = i * theta_step
            z = i * z_step
            r = (1 - z / height) * radius  # Radius decreases linearly with height
            x = r * math.cos(theta)
            y = r * math.sin(theta)
            cmd = dict(cmd='move.linear', feed=1200, x=x, y=y, z=z)
            yield json.dumps(cmd)

    # create generator
    spiral_points = generate_spiral_cone(height=height.state, 
                                         width=width.state, 
                                         revolutions=revs.state)
    
    output = '\n'.join(spiral_points)
    return output

The next two sections move the spiral to where we would actually like it to be drawn with relation to Tobor. Finally we transform the robot code to scara kinematics. We no longer have x, y coordinates we have the angles of Tobor's joints.

Generate the Spiral

We choose the location and the dimensions of the spiral and export the code.

Part 2: Programming Tobor and the NeoBoard

We want to have a programmable RGB Led (WS2812) to be our light source. This led will blink random colors for the ornaments and then return to a green color for the remainder of the time to be the tree.

A single pixel was attached to the front of the 4th axis stepper motor as it was an easy place to affix it. We then used the NeoBoard edge board to control the led.

For Tobor's program we started with everything we already have for the standard Pick and Place setup with the addition of a few elements that can be used to control the led.

The parameters used here are:

• color: This parameter is just used to send some bytes. In this case it'll be used to send something like b'\x00\x03\x01' (0, 3, 1) to send a light green blue color.
• tree_anim: This parameter is used to send a string, which can be used to start the ornaments animation
• tree_delay: This parameter renders a graphic slider in Tobor's web gui so we could easily try different values to see what we liked.

For the NeoBoard program we need to create a few functions to drive the led.

The section to create the ornament animation

• tree_anim: This parameter is used to accept a string sent by Tobor.
• delay: This parameter is used to an int sent by Tobor to set how fast the animation plays.
• do_tree: internal flag used to a see if we wish to continue with the animation.
• set_animation: CodeBlock parameter that contains the animation code.Note this code_block has all three of the above parameters as arguments when it's called

def function(event: string, neo, do_tree, delay):  
    import uasyncio as asyncio
    from random import randint
    colors = ((22,0,0), (11,11,0), (0,0,22), (11,0,11))
    green = (0,2,0)
    
    def get_rand():
        return colors[randint(0,3)]
    
    async def tree_animation():
    	while True:
            color = get_rand()
            print(color)
            neo(color)
            await asyncio.sleep(delay.state/100)
            neo(green)
			await asyncio.sleep(2)
            if not do_tree.state:
                break
    
    async def topper():
        neo((2,2,2))
        await asyncio.sleep(2)
        neo.off()
            
	if event == 'tree':
        do_tree(True)
        asyncio.get_event_loop().create_task(tree_animation())
    elif event == 'topper':
        do_tree(True)
        asyncio.get_event_loop().create_task(topper())
    else:
        do_tree(False)

The next two sections create the Neopixel object and has a parameter called color that will accept a bytearray for color.

Bringing these programs together with cluster canvases

With cluster canvases we can drop both Tobor and the NeoBoard together and network them. See this canvas here https://floe.evezor.com/ide/673f3f1bc7480dcdcanv

By dragging lines between the two we create connections. When Tobor sends a string on it's own tree_anim parameter NeoBoard recieves that message on it's own parameter that is also named tree_anim

Now on Tobor, all you must to is type tree_anim('some string') or color(color) and NeoBoard will recieve that message on the appropriate channel.

Networking devices has never been simpler!

Part 3: Create more fun paintings

Design in Inkscape

To begin we need to create a path for Tobor to take as we're drawing this picture.

See how to export gcode from inkscape in this video tutorial. (Larger text based tutorial coming soon to Hackster)

Once we've created a.gcode file from inkscape we will import it into another program created in Floe tree_light_inkhttps://floe.evezor.com/pyscript/673f94ae8d0b4162canv?core=mpy

This program is pretty much the same as the program from the video except we want to move where this will be drawn from the x, y plane to the y, z plane. That is taken care of in the transform codeblock

def function(event: any):  # This line is auto-generated. Do Not Change.
    import json
    
    def trans(line):
        line = json.loads(line)
        if line['cmd'] in ['move.linear', 'move.rapid']:
        	return json.dumps(dict(cmd=line['cmd'], y=line['x'], z=line['y'], feed=500))
        else:
            return json.dumps(line)
    
    lines = event.split('\n')
	return '\n'.join(trans(line) for line in lines)

Next up we want our tool (the led) to turn on with some color and off on tool_up and tool_down So we are calling the color object we created in Tobor's program, which sends a message to NeoBoard's color parameter, which in turn changes the color of the led.

And when we run the this program and stick the.gcode file we exported from inkscape into the ink_sender gui parameter and hit submit.

Take the Pictures!

To get the desired effect you're going to want to keep the shutter of your camera on the whole time Tobor is drawing and you'll get amazing pictures.

Some of the ones I didn't care for too much

More about Tobor

We've got a lot more tutorials and information coming!

Find out more about Tobor and more on Crowd Supply