Archive for the 'Projects' Category

Line-us Clone Controlled by Easel and Grbl

Last week I made a Line-us drawing robot clone.  Unfortunately I had no good way to make it draw easily.  I thought I would give the CNC toolpath a shot.  My goal is to have a super portable thing to generate conversation at meetups. If I used Easel it would allow anyone with a web connection to easily make something.



Grbl Logo 250px

The most compact machine controller is Grbl and I have a lot of experience with it.  Grbl is designed to send step and direction signals to stepper motors.  The draw ‘bot uses hobby servos.  The nice thing about hobby servos is they don’t need to be homed.  They have feedback to tell them where they are. They also don’t care about speed, acceleration or steps/mm.  They just go wherever you tell them as fast as they can go. It occurred to me, the easiest way to hack this into Grbl was to not modify the Grbl code at all.  I would let Grbl think it is using stepper motors.  I would just add some extra code that runs on regular interval to tell the hobby servos where the stepper motors are in 3D space and they would be told to go there.  I played around with some intervals and 8 times per second (8Hz) seemed to work pretty well.  The ‘bot uses machine coordinates. The work coordinates are offset to the left because the ‘bot cannot draw at 0,0.  The pen would crash into the frame.


I recently port Grbl to PSoC. I used (3) 16bit PWM components to control the hobby servos.  See this blog post on how I did that.  I then attached a 8Hz clock signal to an interrupt.  The interrupt sets a flag when it is time to update the servos.  When the main code sees this flag it does the calculations and and sets the PWM values.  Keeping the code out of the interrupts gets Grbl happier.



Easel is already setup to use Grbl.  You can either import gcode or create a design right in Easel.  I started out with importing gcode because the Benchy design was not in a format I could import. I created a template that shows the allowable work area. This will allow anyone to quickly create a drawing.


2D Benchy

I wanted to have a little fun with the first print.  ”Hello World” was not good enough.  3D printers use benchmark prints, so I thought I would do a 2D version of the classic 3DBenchy.  To get a 2D drawing of 3DBenchy, I traced over an image with the line tool in CorelDRAW.  I then exported a DXF of that.


Hobby/RC Servo Control in PSoC



The PSoC family is my go to line of processors for prototyping.  It is like having a breadboard full of digital and analog circuits that you can wire up on the fly. I have been doing some stuff with hobby servos lately so I needed to figure out how to do it on the PSoC.

Hobby Servos


From Wikipedia


Image from Adafruit


Hobby servos set their rotation based on the length or a repeating pulse. The pulse should be 1ms to 2ms long and repeat every 20ms.  One end of the rotation is at 1ms and the other is at 2ms.

The PSoC PWM  Component


The PWM component is perfect for this job.  The PWM component can be setup to have a period and an on time.  The period should be 20ms and the on time would be between 1ms and 2ms.  The component uses a clock and two counter values.  The component will count on every clock pulse.  It resets the counters after the period count has been reached and the CMP value determines how long the pulse is logic high.

The PWM output goes to the servo control line.  Here is the configuration dialog box for the PWM component. The graph at the top is a good reference for what the output will look like.


The goal is to have a pretty decent resolution to set the 1ms to 2ms pulse.  I chose a 2MHz clock.  I picked the fastest clock that would still fit within the 16bit (65535) limit of the control.  PSoC clocks are derived from system clocks, so you need to pick values easily divided down from them.  The IDE helps with creation of these clocks.  At 2Mhz the period (repeat rate) should be set to 40,000.  The equation is the clock * period(in second) = period counts (2,000,000 counts/sec * 0.02 secs = 40,000 counts).

The CMP Value is how many counts the high pulse should last.  The equation is the same. For 1ms the count would be (2,000,000 cnts/sec * 0.001secs =  2,000 counts) and for 2ms the counts would be 4,000.  The range is 2,000 to 4,000 (2,000 count resolution).  This is better than most hobby servos can do.

The Code

The IDE will generate a bunch of functions, a custom API, for each component used when the application is built. There are two PWM Component functions we need to use for this application .

  • PWM_Servo_Start() This will initialize the component and get it running. This is called once at the beginning of the program.
  • PWM_Servo_WriteCompare(val) This sets the CMP Value that will be used to set the pulse length.

I also wrote a function the can set the value by degrees.

void setServo(float degrees)
unsigned int val;
// convert degrees to compare value
// 2000 to 4000 = 0 to 180
// value is
val = (degrees / 180.0 * 2000.0) + 2000;


The Results

Here is a screen shot of my logic analyzer. The output was set for 1/2 rotation. The pulse is 1.51ms and the period is 20.14ms.  That is close enough for me.  It is likely the clock speed is different between the PSoC and  and the analyzer.



Typically you will have to tune the to the actual servos used.  Just tweak the endpoint values until you get the rotation you want.

PSoC 5 Port Of the Grbl 1.1 CNC Controller

Image from Cypress

Image from Cypress


Grbl Logo 250px


Grbl is a high performance CNC controller.  It is used on a lot of small scale CNC machines and is the motion control code behind a lot of 3D printers.  It was originally targeted at the Arduino 328p hardware (UNO). It is developed  by Sungeun “Sonny” Jeon. He is a good friend.  He is always very helpful and this port would not have been possible without the quality of his code and his advice.

PSoC Mixed Signal Controller

I love working with the PSoC (Programmable System on Chip) family of micro controllers.  You can configure them on the fly with many analog and digital components.  The analog components are not basic ADCs and DACs, you have OpAmps, PGAs,  filters, MUXs and more.  The digital blocks includes basic logic gates, all the way up to FPGA like components you program yourself in Verilog..  There are over 200 ready to use components you can wire together on the chip.

I have always used them for small prototype projects, but wanted to test my skills by porting a major project like Grbl.  At the same time I wanted to take advantage of the features of the PSoC. The dev board I used was the CY8CKIT-059.  This has ARM Cortex M3 processor a lot of I/O and costs less than $10! It has a built in programmer and debugger.


PSoC Advantages

Here is a comparison between the the ATMega 328p (Arduino UNO) and the PSOC5

PSoc 5

ATMega328p (UNO)


32 bit

(ARM Cortex M3)

8 bit


Up to 80MHz

16MHz Typ.

Flash (program size)










up to 62



Grbl’s flexibility allows you to tailor it to your hardware.  With a few limitations, you can move the pins around and change things like whether switches are active low or high.  This is all done using #define values in configuration files.  That is great, but the code gets a little messy every time you access hardware. It has to do a little logic gymnastics each time.

With PSoC you can do all of that in a visual schematic and pin wiring feature.  Here is a PDF of my schematic.  Have you ever swapped transmit and receive on a UART? In PSoC you can just swap the pins on the schematic.

Here is an example of the difference in firmware code.

Grbl on 328p

uint8_t limits_get_state()
 uint8_t limit_state = 0;
 uint8_t pin = (LIMIT_PIN & LIMIT_MASK);

 if (bit_isfalse(settings.flags,BITFLAG_INVERT_LIMIT_PINS)) { pin ^= LIMIT_MASK; }

 if (pin) {  
   uint8_t idx;
   for (idx=0; idx<N_AXIS; idx++) {
     if (pin & get_limit_pin_mask(idx)) { limit_state |= (1 << idx); }

Grbl on PSoC

uint8_t limits_get_state(){  
 return Status_Limit_Read();


Special Hardware Usage

I used some special features to move functions out of code and onto the hardware.  One of them was the step pulse.  Stepper drivers typically require a pulse of a minimum length to take a step.  In normal hardware you have to raise the pin, then figure out a way to turn it off after a given period of time.  This is typically done via an interrupt.  It works fine, but the code is messy and interrupts can cause timing issues.  PSoC  control registers have a pulse feature that automates this. You attach a clock and the clock determines the length of the pulse.  The code sets it and the hardware clears it.  It looks like this on the schematic.



Another feature I used was hardware switch debouncing.  This can be done completely in hardware.  See the image below.  The clock sets the debounce time.  The debouncers are all fed into a status register where they are read  as a single value.  There are digital “nots” after the debouncers because my switches close to ground.  The firmware could invert the logic, but it is so much easier to read on the schematic. It then feeds an interrupt.



If you would rather do this with an analog filter, you can design custom filters in the hardware.  You could fine tune the filter right from your keyboard.



PSoC has a built in character LCD Component that makes using and LCD  very easy.  The code for the LCD is in the main loop and not an interrupt.  This allows the time critical  stuff to have higher priority.  I used an interrupt to just set a flag so the LCD does not update every time through the main loop.  I found the LCD to be an awesome debugging tool.  I could display stuff while the code is running.



I also used a hardware Quadrature Decoder for the LCD rotary knob. This works great to monitor the encoder in hardware.  I just need to read the value in the LCD update routine.  The clock feature on the QuadDec is a debouncer, which helped debounce my mechanical encoder.


Next Steps

I have been testing for a while and so far it is working great.  I want to test it a while longer then post it on GitHub.  I also have some plans to use the extra power on some cool projects.

Here is a picture of my test setup.


A Line-us Clone


I have been going to the monthly Amp Hour, Hardware Happy Hour meetup.  A lot of people bring something to show.  My projects are too big.  Also, you need to bring your own power.  The meetup standard seems to be running off a USB cord. I was brainstorming ideas, when I saw the Line-us project on Kickstarter. It looked like the perfect size and power. I also love the challenge of non linear kinematics.


I decided to make a clone of it.  I started by importing one if their drawings into CorelDRAW and scaling it up to 1:1.  I then added some measurements.  I rounded them up to 80mm for the pen arm and 30mm and 50mm for the linkages.


I looked into hobby servos and found that the “mini” size looked about right.  I ordered 4 of them from Amazon.  I made sure to get metal output shafts because I thought I might have to press them into the 3D printed arms.




I created a basic design in PTC CREO.  I added a lot of construction sketches for the linkages to help me with the kinematics later.  I downloaded a model of the servo from GrabCAD  to use while I waited the delivery.


I used 3mm bearings for all the joints.  These are pressed into the linkages.  This would allow me to firmly tighten the joints and not have to worry about slop in the joints.


When the servos arrived, there were slight differences in from the model.  The mounting holes we much smaller at about 2mm.  I had to reprint with some changes.

My concept was to press the arms onto the servo shafts.  This sort of worked, but after a few crashes, they loosened up.  I ended up using a drop of thick super glue to secure them.  They were able to stall the motor without slipping.  It is important to mount the arms at the precise angle.  I made an Arduino sketch to hold the servo in the precise position while attaching the arms at the angle I wanted.  Each servo has a 180° travel.  The upper arm travels from 135° to negative 45°.  The lower arm travels from 45° to 225°.


In order make the pen go where you want it to go, you have to figure out what angle to set the arms. This is not a simple linear equation. You have to solve a multi-step geometry problem for each new location. I’ll walk you through the basic process. I placed the axis of the two servos at XY 0,0 to simplify things. You know the desired Pen Tip location, so start working back towards the cranks.

  • Step1: Find the Pen A point. You know the lengths of the linkages between the 0,0 point and the pen tip. They are both 50mm. Each arm end has a set of points where it can exist that scribes a circle. If the desired pen point is within reach of the machine, the circles (green ones) will cross at two points. The solution is a well documented process. I used the C code from this page. So far, I found that using the location, of the two, with a higher Y value is the one to use.
  • Step 2: Find the Pen B point. Pen B is easy to find because you now know the slope of the Pen Arm. Multiply the X distance from the pen tip to the Pen A point by the ratio of the length of the pen arm (80mm) over the length of the arm from Pen Tip to Pen A (50mm) and add it to the pen tip. Do the same for the Y axis.
  • Step 3: Now that you know the Pen B location, you can do the intersecting circles (red ones) trick again. This time I used the left most point of the two.
  • Step 4: Find the angles. Use the X and Y distances of the crank tips and the atan function to get the angles. ( angle = atan(deltaY / deltaX) )

Another problem with non linear machines is that moving between two points will not be a straight line. The points will typically be connected with a slightly curved line. You need to constantly recalculate points along the way to keep it straight. If you break a line into smaller segments, the connecting curves also get smaller to the point where they are not notices.





Everything I chose was for prototyping ease and probably not the final solution. I used an Arduino UNO as the controller. I used a PCA9685 based servo motor controller for the servo. The Arduino could probably handle it on its own, but the wiring is so clean and simple with this. I used a breadboard power supply to power the servos. It had a handy switch to kill the power to the servos without killing the Arduino.




The Results

Here is a video of the machine running. The rectangle is hard coded via some for loops recalculating at 1mm increments. The results are shaky, but consistent with the Line-us results. The machine is quite rigid. Most of the shakiness comes from the servo motion. I also do not have the machine held down. If I get some magnets like Line-us, it might help.


Open Source (sorry)

I don’t think it is fair to the Line-us folks to release any files at this time. I think there are plenty of resources in this blog post if you want to clone it yourself. So far I only have about 5-6 hours into the project, so it is pretty a pretty easy project.

The real Line-us looks very polished and they are selling it at a good price. I am sure a lot of the work they did was on the UI, which I did not replicate at all.

Next Steps

I need a way to stream drawing data to the machine. I would like to use g-code. It also needs a UI and I thought Easel might be best. For the gcode I might try hacking Grbl. I would just add a timer that reads the current location at about 5hz, send it through the math and set the servos. Any value above Z 0 would be pen up.

For Easel, I could create a template that shows the usable work area. You would then just click Carve






The Bipolar ORD Bot



It’s ORD Camp time again this weekend.  Every year I have done a gonzo build of some type of CNC machine.  This year I only had a few hours to spare, so I wanted something simple.  These are never meant to be practical machines, just conversation starters.

This was hacked together and programmed in about two evenings with stuff I had laying around, but working at Inventables means there is a lot of cool stuff “laying around”.  It was inspired by the RepRap Wally 3D printer, but vastly simpler in construction.  This only uses a couple of fabricated parts.  There are (2) sets of indentical actuator arms.  The inner arms are hard mounted to small NEMA 14 stepper motors.  The other end is attached  to a wood base, but free to rotate on a bearing.  The outer arms are mounted to the stepper motor shafts using Actobotics hubs.  The other ends have 1/4″ I.D. flange bearings.  These are bolted together, but free to rotate using a screw with a holed drilled for the pen.  That is basically it for the mechanics.

The stepper motors are driven with some high resolution stepper drivers.  These are driven by stock grbl 0.9 firmware running on an Arduino UNO.  The UNO does not know what the heck it is driving though.  The resolution is done in degrees.  I wrote a quick conversion tool that converts Cartesian gcode to bipolar gcode using these formula.

  • L = 150mm
  • A = 90mm


I have my CAM software output circles as multiple lines, so circles don’t need to be dealt with.  It has an odd, shield, shaped work area that you need to stay within.  Before powering on the steppers, you place the pen at the top middle of the work area.  You then tell grbl that both angles are at 51 degrees with G92 X51 Y51.



Here are a few more pictures taken at this weeks Beer and Making session at Inventables.

0121151912 0121151912b 0121151912c


The shield has a solenoid driver that I was going to use for pen up, but I never got around to that.  I kind of like how it runs so silently.

Here is a video of it running.  It is rerunning over an old plot to show the repeatability.   I think if I used true inverse kinematics the plots would look even better.  Maybe Machine Kit on a Beagle Bone is in its future.


A few people have asked if the motors could be moved to different locations.  Yes, I think you could put the (2) motors on any (2) joints and still have a controllable machine.  Not all work areas would be the same size and some might have issues with much higher torque requirements.  I believe separating the the motors by one linkage, like this one, yields the best results.

Skate-oko-asaurus: The self replicating skateboard

We build a lot of skateboards for fun at Inventables.  Some of the guys even sell them at local craft fairs.  They thought it would be cool to have a CNC router optimized for skateboards that was easily portable.  I first thought about putting wheels at one end, then realized the machine itself could be a skateboard.  We thought it would make a perfect Gonzo Build.

2014-10-26 11.00.15

A Gonzo Build is something we came up with at Pumping Station One CNC Build club.  The concept is that we try to build an original, “one off”, CNC machine in one evening.  They also tend to have a whimsical aspect to them, so we don’t take ourselves too seriously.  We usually get about 8-12 people to help build.  If parts need to be fabricated, they must be done that night on -site.

2014-10-26 11.00.50

Building a stock Shapeoko 2 in one night is a challenge in itself, but we decided to up the challenge by totally tricking this out with every feature we could think of.  We did have a few master CNC building ringers in the group, like Tait Leswing and David Ditzler.

Here are the stats of the machine.

  • 1200mm x  250mm work area
  • Skateboard specific wasteboard supported by additional extrusions.  It is narrower than a stock Shapeoko 2 and about 3 times as long.
  • Drag Chain
  • gRAMPS Controller running grbl 0.9.
  • Quiet DC spindle with full speed control.
  • Feed hold / Resume / Reset buttons
  • Homing switches on all axes
  • Auto Z zero with Z probe
  • Trucks and wheels
  • NEMA 17 motors with dual Y stepper drivers.
  • Portable dual 24V/48V power supplies with master power switch.

2014-10-26 11.18.20



Most of the Shapeoko parts came from reject area at Inventables, so there are a few dings and scratches.

The wasteboard was cut from 5/8″ particle board on the PS1 Shobot.  It has a grid v carved into the work area.  There are threaded inserts for clamps, primarily around the perimeter, but there is a truck bolt pattern strategically placed so a cut out board can be flipped or remounted accurately . It is supported below by 2 additional MakerSlide pieces and tied to the MakerSlide rails above.  It is the bed turned out very rigid.  It does deflect a little with heavy rider but pops right back.  After the build, I added several coats of spar varnish to ward off the dusty footprints.  Biggest guy to ride it so far tips in at about 230lbs.


We set our selves a goal of completing before midnight.  Done or not, I was going to ride it at midnight.  We thought we were finished about 20 minutes early.  Everything worked fine except the Z axis was not moving correctly.  It had the classic stutter and random motion of one coil wire not connected.  We tried to find the problem, but over 2 meters of drag chain slowed us down.  Midnight came some we dropped it to the floor and I rode it across the shop.

2014-10-26 11.03.30

As a skateboard, it is pretty much a joke.  On the first ride, we didn’t even have long board trucks, so the turning radius was huge and you can easily scrap an edge.  The front has a handle cut into the nose of the bed.  The ideal way to move it around is to lift the front and drag it on the back wheels.




grAMPS 1.0 Stepper Motor Shield


The newest version of the CNC controller software, grbl (0.9g at this post) has a lot of cool new features, but the two that caught my attention were the ability to compile and upload from the Arduino IDE and support for multiple Arduino types including the Arduino Mega 2650.  I have always found the I/O count and memory of the Arduino UNO very limiting.  I quickly compiled it onto a Mega and hand wired a RAMPS board for testing.  It worked great.


The RAMPS board is a famous open source RepRap 3D printer controller.  It is an acronym for Reprap-Arduino-Mega-Pololu-Shield.  It is so simple and hackable that I have used it for dozens of CNC projects. The RAMPS board made it easy to hook up all the wires, but you can’t just plug it into MEGA because grbl requires that certain I/O is grouped into a single I/O port.  RAMPS was designed for 3D printer firmwares that do not have that limitation, so things like X,Y and Z step are not all on the same port.  I am sure you could hack grbl to break that limitation, but I wanted to only touch the config files.

The RAMPS also has a ton of features, like (3) thermocouple inputs that are not needed, so I decided to make my own version of a RAMPS with just the features that a CNC router like the Shapeoko needs.  When I realized I could use the name grAMPS (grbl+RAMPS), I wanted to get it done as quickly as possible.  Here are the features I implemented.

  • Stepper drivers for X, Y and Z.
  • The Y axis is setup for dual drive with two ganged stepper drivers (like Shapeoko).  If you wanted dual on a different axis, you just need to modify the pin mapping a little.
  • A spindle control circuit.  This uses a high power MOSFET.  I have it hooked up to a 10 bit PWM channel.  It works great with no thermal issues.
  • Separate power inputs for the Stepper Drivers and the Spindle so these can be run at the optimal voltages.
  • There are terminals to hook up a fan to cool the drivers using the motor power supply
  • X, Y and Z limit switches are brought out to a terminal block.
  • The Z probe function is brought out to a terminal block.
  • There are buttons for Feedhold, Resume, grbl Reset and Arduino Reset.
  • IOREF is used for the stepper driver logic voltage, so you could try this on an Arduino DUE board.  There is a jumper in case you have an old Arduino that does not have the IOREF pin.
  • Microstep selection jumpers.

I hand assembled one in about 30 minutes.  The part count is quite low.


Final Thoughts

The only thing I would change is the power terminal blocks.  There are a little small for heavy gauge wire.  Everything else I like.  I like the clean layout. I love how fast and easy it is to assembly.  The parts cost is quite low except for the 0.10″ pitch terminal block.  That is a couple dollars by itself.

I have about 15 raw boards.  I would love to get them in the hands of some CNC builders.  I will be at Maker Faire NY.  Find me or tweet me, @buildlog, during the faire for a free one.   My hackerspace, Pumping Station One, will have a booth there.  I might spend some time there.


Source (CC-A-SA)


Schematic 32028

Gerber Files 16030




Camera Slider Controller Hack


I have been having fun with my camera slider controller.  It is a cool, little, general purpose motion and camera controller that will soon to go on sale at Inventables. Taking a picture is very easy.  You just plug the camera into it and run the takePicture() function.  It has a lot of spare I/O pins that can be used for some cool hacks.

I always thought it would be cool to take a time lapse movie of a 3D print, but do it exactly one layer per frame and have the picture be taken at the exact same location every time so the print appears to grow out of thin air.  I know people have done this before, and I could probably hack the circuit right onto the printer controller, but camera slider controller was ready to go with the circuit and connectors all ready to go.  With less than ten minutes of coding and making a cable, I was ready to go.

GCode Hacking

The first task was hacking the GCode to output a a signal I could read remotely.  Kisslicer has a feature where you can add a few lines of Gcode every “N” layers.  I added the following GCode.  Note the “1″ in the layers box.  This means do it every layer.




G1 X0 Y0 means move to 0,0

G4 P500 means dwell for 500 milliseconds.  This was added because the next command was happening before the move completed.  I think this has to do with the way commands are buffered.  I think there is a more elegant fix for this, but adding a little delay here was a quick fix.

M42 P11 S255 means set I/O pin 11 to full on (255  is max).  Pin 11 is the first of the “servo” pins on my RAMPS controller.  This three pin connector would map directly to the servo connector on the camera controller.

G4 P1000 is a 1 second delay.  I had my DSLR on “auto” so it would need to focus for each shot, so I gave a little extra time.

M42 P11 S0 turns pin 11 off.

I ran a few test layers with my volt meter hooked up to the connector and it looked great.

Camera Slider Controller Hacking

The controller has 2 servo connectors that are intended to be used for hobby servos in a pan and tilt arrangement.  The signal pin on the connector can also be used as and input.  The code is simply going to watch for that pin to go high.  When it does it will display the next layer number and take the picture


Arduino Code

In the setup() section you need to make the PIN_SERVO_1 pin an input because that is connected to the printer controller.

pinMode(PIN_SERVO_1, INPUT);

The loop() section looks for the PIN_SERVO_1 pin to go high. When it does the layer number is incrememented the picture is taken and the LCD is updated. The camSignalRead flag is set so we don’t go read the same pulse more than once. The flag is cleared as soon as the signal

void loop() {

   if (digitalRead(PIN_SERVO_1) == HIGH) {
     if (!camSignalRead) { // make sure we read once per pulse
       camSignalRead = true; // 

       lcd.cursorTo(2, 0);
       sprintf(sVal, "Layer %d", layerNumber);


   else {
     camSignalRead = false; //reset this. the pulse is over 



Simply connect the signal pin (D11) on the servo 1 connector of the printer controller to the signal pin on the servo 1 (J7) connector of the camera slider controller. You also need to connect together a ground pin on each controller.






Camera Setup

I setup my DSLR on fully automatic and disabled the flash. I am sure the movie would have been better if I manually focused and locked the speed and aperture settings, but I just wanted a quick result. The controller first sends a focus signal and then a shutter signal. The focus signal acts like the half button push you do to focus most cameras.

The Print

The printing was done on the Quantum Delta printer.  I used my CNC Ninja Squirrel as the test print. It was scaled to 50mm tall. At at 0.25mm layer height, that gave 200 layers. The print took about 45 minutes with the added delays. It was run in a busy room at Pumping Station One so there was a lot of activity in the background and some light level changes.



The Result

Click here if the video is not displayed below.


The Quantum ORD bot

ORD Bot 3D Printer

Update:  This is now available at

I was invited to this really cool event called ORD Camp. ORD Camp is unique, yearly event put on by Inventables and Google in Chicago. It brings together 200 people with a far range of interests. The common thread is a exceptional passion for what you do.

You are encouraged to bring a “creation /invention” you are working on. I did not want to bring the 2.x laser because it is hard to move around, it takes up a lot of space, and is not real conducive to just operating in the middle of a room. I will probably bring the camera slider, but I really felt like using the opportunity to create something new and cool with the MakerSlide material.

I was recently inspired by this Kickstarter Printrbot 3D printer. It seemed like a real ‘outside the box’ look at 3D printers. Brook of printrbot contacted me recently about collaborating with some of the people he is working with on some projects which got me more inspired. I decided to try a similar concept using Makerslide.

MakerSlide has these main features. It is a linear bearing. It is a structural element. It is accurate and it is cheap. The concept is, if you keep some of this laying around and have access to a few tools, you can quickly brainstorm an idea and fabricate it right away. This project was hashed out in about 3 hours, fabricated in about 2 hours and assmebled in about 2 hours. That includes cutting all the custom parts.

The result is the ORD Bot 3D printer platform. The structure and linear bearings are 100% MakerSlide. The motion is smooth, ridged and accurate . The parts are cheap. This uses less than $60 dollars worth of MakerSlide rail, wheels and idler pulleys. The rest are off the shelf items or fabricated by CNC router, laser cutter, 3D printer or other means.

A huge feature of this design is the scalability. It can scale in X,Y, Z or any combination by simply using different lengths of MakerSlide. All brackets stay the same. You might need to change belt lengths, but all the belts are open ended belts, so you don’t need the exact length, just some belt stock. The lead screws also need to change if the Z changes, but that is standard cut threaded rod. The version I built is probably as small as you would ever want to go, so I called it the Quantum ORD Bot. The build area is slightly larger than a standard MakerBot.

The frame is extremely ridged. Cut squareness does not matter very much. Every parts has multiple adjustable points and does not rely on the quality of any cuts. Parts can be aligned with a square and bolted down.


I initially had some screw on leveler feet in the design, but after some design tweaks, extra bracket were going to be needed to mount them. I made these feet out of HDPE. They are soft and will not scratch any surface. I added the holes at the bottom to get a little spring to them, but I also think it brought in a nice design element. The rounded end and three point contact make them self leveling. The rear feet also act as a secondary brace for the Z axis.


The handel is not required, but adds a lot of strength, can be used to mount electronics and also serves as a gauge for alighning the uprights. If you use a handle and scale the X axis you would need a hew handle. An alternative is to use a standard 20×20 t-slot piece across the top.


Here is the build area increased by 100mm in each direction. I put a 20×20 extrusion across the top instead of the handle. I just did it as an example to show a more easily scaled version. This cost would be $4 higher for the MakerSlide about $3-$4 more from Misumi, about $2 more for longer lead screws and about $5 more for the longer belts. You would also need a bigger build platform (not shown). The total increase is easily less than $20. The increase in Z weight is about 4 ounces (0.1kg). At very large widths you might want to add a second Y axis extrusion, but that would just be a repeat of the existing one.


The pictures above are mostly renderings.  Here are some real pictures of the prototype.  I cut all the parts on my CNC router.  I could have used my laser cutter, but I wanted to make a few counter bores for some screw.  I don’t think that is needed, but it looks cool.  I also used some optional non laser cuttable materials like carbon fiber and HDPE.

I came up with this idea about 6 days before the ORD Camp date, so I was a little rushed.  The biggest problem was lack of motors.  I also was so busy that I really could only allocate about 6 hours to the project.  I let the delivery time of the motors set the schedule so only worked an hour or so a day over the week.

This design is very strong.  I could stand on it or hang from it without damaging it.  It is quite light at about 6.25 lbs.  I am very happy with it and hope to get some good feedback at ORD Camp.




Where Are The Wires?


The element I really liked when I did some initial renderings was the clean look. I knew it would quickly turn into a RepRap hair ball as I wired it, so I decided to take advantage of the built in passage ways in the MakerSlide. I drilled some holes into the faces in some areas to pass the wires from extrusion to extrusion. The wires to the gantry had to be exposed because they move with the gantry.  I put the wires into an extrension spring.  This is a 1/4 O.D. 0.018 wire springs.  If you stretch a spring the diameter reduces.  I used this feature to mount the spring.  I drilled holes slightly less than 1/4″ and stretched the spring through the holes.  When I released the spring the diameter expanded to fit snugly in the holes.  I tried to find a tap that matched a spring pitch so I could just thread the spring in, but couldn’t find a match.  This mod falls into the “its not worth doing, unless you overdue it” category.  I also wanted to reinforce the extreme rigidity look, by using carbon fiber parts, but the budget limited me to just the small thin parts. Again, this was overkill and just for fun.

What is Next?

If there is any interest, I might add this as a kit to the Makerslide store.  I would like to quote all the carriages and brackets in aluminum, so I don’t have to fabricate much.  I would probably need a 50 piece buy to justify the work and cost.


Edit (2/11/2012)

You can get the source files at Here.

Here is the ORD Bot running at 160mm/sec, but the current print speeds are exceeding 400mm/sec with 1000mm/sec rapids. The limiting factor right now is the extruder, but we have preliminary prints close to 500mm/sec.

Using a ShuttlePro as a Laser Pendant

I have been using a ShuttlePro as a pendant for years on my router.  A pendant is basically a hand held remote control for your CNC.  It allows you to control a set of functions right at the machine.  I typically use it to zero the machine on the part, tweak the feedrate, start/pause/restart the job and do an e-stop.

The router’s pendant is starting to die.  It has been through hell.  I have dropped it about 10 times on the concrete floor.  It has also seen a lot of oil and fine dust.  A couple buttons are getting intermittent.  I have the functions to working buttons, but I was getting worried it would stop working completely.  I could not live without it, so wanted to get a replacement on order.  I found a good deal on eBay ($54) and since they had several, I decided to get one for the laser as well.

The ShuttlePro was designed for video editing.  One thing you do a lot in video editing is jogging the video forward and backward.  Typically you want to race forward until you get close then slow down and even go frame by frame until you get to the desired spot.  Sounds like CNC doesn’t it?  It has three dedicated functions for this.  Full speed forward and back via buttons, variable speed via a spring loaded jog dial and a frame by frame little detented rotator wheel.  It also has a lot of redefinable buttons.  These buttons have clear snap on caps, so you can add labels to them.  I have a Corel and PDF template at the end of the post.  Someone at the Mach3 forum dicovered this product and within days there was a plugin for it.

Setting it up is easy.

Download the ShuttlePro plugin from the Mach3 downloads page.  Place the ShuttlePro.m3p file you download in a convenient place like your desktop.  Double click on it.  That will launch a program that registers it with Mach3.  Plug in the ShuttlePro into your computer.  It uses the built in Human Interface Driverss (HID) so you do not need to install a driver.  It comes with some software to test it, but you must uninstall it before using Mach3.  Start Mach3.

Use the config Plugins menu pick to open the

Make sure the plugin is enabled with a green check.  Now click on the word config to the right of the plugin name.

That will bring up the screen above.  Each button can be associated with any of many functions.  My config is shown above.  You probably want some keys across the top to select the current axis.  I like to have the two buttons to the outside of the central wheels be rapid movement buttons.  It is also handy to be able to lock the pendant so accidental button pushes do not screw up a run.   I used the second button from the lower right.  The rest are up to you and how you use your laser.

Below is a video demonstration on my laser.