Archive for the 'DIY' Category

Bus Servo Draw Bot

I wanted to complete a start to finish project with the LX-16A bus servos to do a complete review of their viability for the type of mechatronics projects I do. The low price of the LewanSoul bus servos make them a competitive option over digital servos. I chose to do a remake of the Line-Us clone drawing machine because I would not need to spend too much design time and it would be a good 1:1 comparison with digital servos. Since the bus servos are quite a bit larger, I decided to scale up the machine by 1.5x.

Made My Own Brackets.

I started by buying one servo and it came with brackets. When I went to get more, I noticed the price was lower. I did not realize I was getting these without brackets. These are the brackets you get with the more complete kit.

I requested some 3D models from LewanSoul. They were only able to provide 2D DXF files, but they were easy to convert in Fusion 360. This allowed me to 3D print some brackets. It actually worked out quite well because I was able to thicken up the brackets and integrate some captive square nuts.

They mounted easily to the servos and were plenty strong for this project.

Servo Arms

I made two arms and one short cam for the Z. They were about 4mm thick and had a little pocket that slid over the standard round actuator. They screwed on with the screws that come with the servos. Before mounting anything I turned on the servos and moved them to the center of the range. This put the arms at a known angle.

Support Bracket and Base

The support bracket holds all three servos and there are 2 pockets on the bottom for some shaft bushings.

The base has two shafts pressed into it.

The shafts slide into the bushings and there is a spring to hold the parts together.  The spring prevents the pieces from separating and also provides a little extra pull down force in case the shafts bind a little. The cam provides about 6mm of lift.

Final Assembly

The servos are mounted to the support bracket.

The wires are connected to the servos. They just daisy chain from one servo to the next.

The remaining links are then connected.

Testing

Here is a video of the first run.

Results

I think these are a good alternative to digital servos. They are very strong, easy to mount and accurate. Depending on the design of the controller, using a simple UART might be easier than having multiple PWM signals or extra hardware. The servo’s size might be larger than some machines need but that comes with the higher power.

 

LewanSoul Lobot LX-16A Serial Servo Review

I stumbled upon these LewanSoul LX-16A Servos the other day on Amazon while searching for standard digital servos. These servos are digital serial bus servos. That means they use a serial protocol on a bus rather than a PWM signal. I have used bus servos before, but the $12 price got my attention. That competes well with plain old PWM servos.

Serial bus servos have some real advantages over standard PWM servos.

  • Wiring: The wiring can be a lot simpler because you can put all your servos on a single 3 wire bus. Each servo has 2 connectors to make daisy chaining easier.
  • Higher resolution: The resolution is typically higher. It depends on the way they sense position. These use a high accuracy potentiometer and list 0.24° as the resolution.
  • You can set the speed: You can set a destination and speed for each move.
  • Set the range: You can limit the range of the servo. This is great if the using the full range would crash a joint on your machine.
  • Continuous turn mode: There is a speed adjustable continuous rotation mode on these, but absolute distance moves cannot be done.
  • Motor On/Off: Turn the motor off for manual movement.
  • Feedback: The communication is bi-directional so you can query a servo for…
    • Position: If you manually move a servo, you get its position. This is great for recording “poses” or setting range limits.
    • Temperature: You can read the current temperature of the motors.

Compared to Robotis

I have used the Robotis Dynamixel XL320 servos before but these are a lot stronger and the XL-320 has a weird, plastic rivet, mounting systems that I am not fond of.

Here is a size comparison with a XL-320.

Specs

Spec LX-16A XL-320
Max. Torque 17 kg-cm 4 kg-cm
Resolution 0.24° 0.29°
Range 240° and Continuous Rotation 300° and Continuous Rotation
Speed 62 RPM 114 RPM
Weight 52g 16.7g

Usage

To use the servos you need to use one of their controllers. The most basic controller just converts a USB or TTL serial signal to their protocol. The controller is small and low cost ($10). You can send commands via a USB (Com Port) or via the TTL pins.

Setup Program.

They have a setup program.  The program is Windows only and I had to run it in Administrator mode to get it to work. This makes setting up the servos easy, but you could write your own program if you don’t want to use theirs.

TTL Control

They also provide some Arduino Sketches. They worked fine and are a good place to grab some code if you are writing your own program.  The sketches use the Arduino hardware TX and RX pins. That conflicts with uploading, so you need to disconnect the controller every time you upload. I edited the sketch to use SoftwareSerial on some other pins and that made playing with the code a lot easier.

First Impressions

I found the servos very easy to use and they appear to be strong and responsive. I think they will be a good option for my on my machines.

Next Steps

I want to test these in a real machine. I thought I might try to make a slightly larger version of my Line-Us clone. That would be a good comparison of accuracy. I might try one day build on it tomorrow.  I can probably get a machine designed and built in a day, but the controller programming would need more time.

 

The Polar Coaster – A Drink Coaster Drawing Machine

I designed this machine to draw custom, round drink coasters. I already have a laser cutter for square coasters and I wanted to try something unique for round coaster.

The Base

The base of the machine has two stacked 5mm bearings in the center for the bed to rotate on. There are (3) 3mm bearings on the bed perimeter that provide support and keep it level. They have little shafts that snap into the base.

The Bed

The bed is  a 156 tooth GT2 pulley. It has little springy fingers that grip the coaster when it is on the bed. The bed connects to the motor pulley with a closed loop belt.

The Radial Arm.

This is a belt driven, cantilevered arm that uses 6mm shafts and linear bearings. The belt is a cut pieces with the ends clamped at the carriage. It has a slotted mounting hole that lets the arm rotate. The pen must be adjustable to get to the exact center of the coaster or the drawing will be distorted. There is a limit switch on the top.  This is the only axis that needs to be homed. To setup the machine you home it and jog the pen until it is exactly over the center of the bed. You then set the work zero for X (Gcode: “G10 L20 P0 X0”). This only needs to be done once. If you use different types of pens, the center should be rechecked.

The Z Axis

The Z axis uses a micro servo and a cam to control the height of the pen. The firmware is setup to only have (2) Z positions, pen up and pen down. It uses 3mm rods and tiny little 3mm linear bearings.  There is a compression spring on one of the rods that applies a little pressure to the pen, and allows the pen to float a little on uneven coasters.

The Controller

I used my Grbl HAT controller. It is a bit overkill for this project but works perfectly.  It is attached to a Raspberry Pi in this photo, but I have not been using the Pi in this project yet. I just connect directly via USB.

Kinematics and Pre-Processin

See this blog post on how it was done. The pre-processor is written in C#, but it is rather simple and you could probably read the source file and convert if you cannot deal with C# on Windows.

Firmware

I use a modified version of Grbl 1.1f.  Grbl does not support servos, so I needed to hack that in.  I used the PWM that is normally used for the spindle speed to control the servo. I turned off the variable speed spindle option and streamlined the spindle functions to the bare minimum I thought Grbl needed.  I adjusted the PWM parameters for use with a servo and added pen_up() and pen_down() functions. I tried to put as much of the custom code into one file spindle_control.c. I had to add a few lines in stepper.c to look at the current machine Z height and apply the correct pen up/down function.

CAM

You can use anything to generate the gcode that works with Grbl. The pen will go up when the Z is above zero and down when it is below zero. Therefore, you want the Z movement as short as possible to speed up the drawing and not have the pen dwell on the material and bleed.  I make the depth of cut 1mm and the z clearance 3mm.

CAD Files.

The design was done using PTC CREO 3.0.  A STEP version of the design is linked at the end of the post.

Performance

It does a great job. Here a recent coaster. This was done from a rasterized bitmap image found online (searched: circular Celtic braid).

Here is a Fat Tire beer themed coaster.

Coasters are made to be super absorbent, so larger tipped felt pens tend to bleed a little too much. I like to sketch with Micron pens and the thinner ones really work well on this machine.

Build You Own?

The build is not difficult, but covers a lot of areas. You should know how to work with STEP files and compile firmware.

The design is open source with no commercial restrictions, so feel free to use any part of my work. I found most of the parts on Amazon and eBay. I bought the belt from Stock Drive Products. The polar motor pulley is 36 tooth and the arm pulley is 20 tooth.  Cutting the shafts requires an abrasive cutoff wheel.

Please post any questions in the comments section and I will try to address them.

Links

 

 
I sell on Tindie

 

 

 

Lost PLA Casting

cast2

We recently did some aluminum casting at the Inventables Beer and Making night. The primary mission was to do some lost foam casting, but I wanted to try lost PLA.

Beer and Making is typically a gonzo/hackathon type event, so we deliberately try to use materials on hand and try to learn for ourselves. We used pink insulation foam because it could be easily hand carved during the event. This was the first time for everyone, so I was quite happy with our success.  I’ll point out some areas where we probably could have done better.

The furnace

One of the perks of working at Inventables is our personal Exploration and Project budgets.  We all get a budget for personal exploration and making things. The furnace was recently purchased by Jon, one of the fulfillment team members, with some of his budget. This furnace runs off standard 110V and can heat the material up to 1150°C.  We set it for about 1000°C for the aluminum.

furnace

 

The Model

sprues

 

The model I used is the unofficial mascot for the CNC build Club, the CNC Ninja Squirrel.  I tried to use as little PLA as possible.  I used 2 perimeters and 5% infill.  There are a few steep overhangs, so I typically need at least 2 perimeters for success with this model. I didn’t use any special filament, just the PLA was in the printer at the time.

The model will be buried in the sand.  You need to create a couple of channels (sprues) to reach the surface for the casting process.  The channels have several functions.

  • Provide a place to pour the aluminum.
  • Provided an escape path for the air and other gasses created when the material is burned out.
  • Provide a a source of aluminum for the part to draw from when it shrinks.

I created the channels from pink foam and hot glued them onto the PLA model.

The Sand

We used what we could find quickly.  We used about 9 parts of a play sand and pool sand mixture and 1 part of bentonite power (the Tait mix).  We added just enough water to make it clump a little.

The Setup

cast1

We got a large metal metal tray and put some dry sand on top.  This was a bit of a fire pit in case of any spills or fires.  You can see the size of the crucible in the foreground and the tongs that came with it.

We made a small enclosure out of MDF.  We filled it half way with the sand mix. We placed 3 items to cast in it.  We then covered the items in sand.  We added the sand slowly and packed it down with a rod at several levels.  We poured each of the 3 items with separate pours.  We wanted to make sure each item got a lot of aluminum.

We used scraps of MakerSlide as the aluminum to melt.  We cut the pieces to the length of the crucible.  We would add a piece at a time as they melted.  It took about 30 minutes for the first batch and about 10 minutes for the other batches.

Pouring

IMG_1722

The pouring was pretty exciting.  Some of the aluminum ran to the MDF sides and started a little fire.  We had a fire extinguisher ready, but simply put a cover over the box to kill the flames. Most of the flames you see in the image are the foam being burned away.

Results

We did three separate parts.  2 were foam and 1 was PLA.  The PLA probably had the best quality finish, but the part came out noticeably darker.  It was easy to clean up with a stiff wire brush.

Next Time

  • The first change I would make is to use something non flammable for to hold the sand.  I think a ceramic flower pot might be good.
  • Build up the sand around the sprues to keep the aluminum from spreading.
  • Cover the part in dry wall paste.  This creates a thin shell between the part and sand to get a better finish.
  • Get some better sand and a little fire clay to make a better sand mix.
  • I might try to model the sprues onto the part in PLA
  • Mark the in and out sprues, so you know what side to pour into.
  • The smoke and fumes were pretty nasty, especially the MDF.  Do this outside!

 

 

Digital vs. Analog Servos

wiggles

There is quite a bit of wiggliness on my drawing bot. While it is a bit adorable as it draws, I wanted to see if I could improve the line quality. I thought increasing the the rate at which I updated the position would make it smoother. I took it all the way up to 48Hz, but was not getting much better quality than I did at a 1/4 of that.

Analog Servos

I little research into analog servos brought some possible solution to light. Analog servos are controlled with a PWM signal.  The PWM pulse should be between 1ms and 2ms and repeat at 50Hz.

servo_timing

The basic technology inside an analog servo has been around longer than I have. The circuit converts the signal pulse into a voltage based on it’s length.  The output shaft is coupled to a potentiometer which also outputs a voltage. These two voltages are compared to produce an error voltage.  The error voltage would be positive or negative based on which direction off the output shaft potentiometer is from the input signal voltage.  This voltage is sent through an amplifier and then to the motor.  The motor turns in the proper direction until the error voltage is zero.

aservo

One problem with this method is the voltage to the motor is proportional to the error voltage.  The motor will have very little torque when the error is small, as would occur with small moves.

To keep the servo from being overly sensitive to small changes changes in the pulse length, the servos have a deadband.  Over sensitivity would cause jittering and use a lot of power. The deadband is expressed in microseconds (us). Analog servos typically have a 5us deadband. If the error is less than the deadband, the servo will not move.

If the servo pulse range is 1ms to 2ms or a 1000us range, then this causes the second problem. A  1000us range divided by the 5us deadband is 200.  This means I basically have to move more the 1/200 of the usable range to get it to move.  The full range is 180° so I have roughly 1° resolution.  That will cause lines to look very jittery.

Try this to get a feel for an analog servo.  With the servo receiving a commanded position, attempt to rotate the output.  You will notice two thing. First you will notice the strength of the servo is proportional to how far you twist it off the commanded position. The second thing to notice is noise and vibration.  That vibration is the 50Hz PWM period.

Digital Servos

Digital Servos use the same same basic input method (1ms to 2ms pulse) to preserve backward compatibility, but everything is done digitally.  Additionally, most of the servo’s parameters can be programmed. The digital circuit does not need to be limited to the 50Hz period and the control loop can be more sophisticated than simply using the error voltage.

The two immediate things I can take advantage of is lowering the deadband.  I can program it down to 1us or on some servos even lower. This give me a 5x improvement in resolution.  The other thing is the higher torque at small moves.

Try this to get the feel for a digital servo.  With the servo receiving a commanded position, attempt to rotate the output.  You will notice two thing. First you will notice the strength is very strong regardless of how far you twist it. The second thing to notice is noise and vibration.  That vibration is going to be a much higher pitch.

The results.

digital_wiggles

The results are subtle, but I think it is better.  With no changes to the firmware it got a little better.  I changed the update rate from 50Hz to 200Hz and it got a little better again.

I used Hitec HS5055MG servos.  I wanted a brand name servo, I know I could program.  Out of the box the servo only had about 90deg of rotation.  I was able to up that to about 178.  I was quite surprised I could not get 180°.  That needed to be accounted for in the kinematic or the shapes are distorted.

I think if you want the best, go for the digital, but in my opinion, the improment in quality did not justify the cost.

 

 

Hobby/RC Servo Control in PSoC

psoc_setup

 

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

Wikipedia

From Wikipedia

servo_timing

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

PWM_Comp

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.

pwm_setup

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;

PWM_Servo_WriteCompare(val);
}

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.

capture1

 

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

A Line-us Clone

image1

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.

8d65c4576042e58c834aa36d1098ceb6_original

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.

measurements

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.

mini_servo

 

Design

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.

design2

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.

Assembly

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°.

Kinematics

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.

 

 

kin2

Electronics.

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.

pca9685-16-channel-12-bit-pwm-servo-driver_1

PowerMBV21

 

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.

image2

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.

 

Firmware

Here is the firmware I used.  It is a quick and dirty port of my PSoC port of Grbl. I cannot give support for this. Only experienced PSoC programmers will be able to install and use this.

Grbl Line-us PSoC Firmware

CAD File

Here is my STEP file of the design. This contains all of the printed parts and some of the hardware.  You will need to figure out a few things on your own.

Line-us Clone STEP File

 

 

 

 

 

 

grAMPS 1.0 Stepper Motor Shield

gramps_build

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.

grbl_ramps

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.

gramps_test1

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.

grAMPS_pcb

Source (CC-A-SA)

gramps_top

Schematic 32028

Gerber Files 16030

 

 

 

Bridgie – A new look for a CNC router

Bridgie CNC Router

When our Hackerspace, Pumping Station One, had it’s mini router repossessed by a member who was leaving, I decided to design a replacement.   As always, I wanted to try out some new ideas on the build.  I also wanted a project made primarily in metal to force me to get up to speed on using my CNC Bridgeport.  The result is Bridgie.

bridgie_01

Bridgie?

Bridgie was inspired by the Bridgeport’s sliding X axis, so the working name became Bridgie.  The other inspiration came from a sliding chop saw.  This was used on the Y axis.  The Y axis is remarkably stiff and makes the Z far stiffer than many other routers I have used..  All rods except for the Z are 20mm hardened steel and the 12mm ball screws add strength.  The X is even stronger and the bearings always stay directly under the spindle.  The entire machine weighs about 45 lbs..

Bridgeport  Bosch_10_Sliding_Miter_Saw_Large

 

Clean Design

I wanted a very clean design, so I designed it so it is totally self contained.  The power supply, controller, limit switches and motors are totally contained inside the body of the machine.  The only external interfaces are power and USB on the back.  There is also a fan on the back that blows directly on the motor drivers and flushes any hot air out of the interior.

Spinning Ball Nuts

It uses 12mm ball screws on the X and Y axes.  In order to bring the motors inside, I decided to use spinning nuts and stationary lead screws.  This actually simplifies things because you don’t need to put expensive bearings on the lead screw, you just firmly attach it to the end plates.  The lead screw becomes a structural member in the machine.  The bearing on the nut is important for reducing backlash, so I used a large dual angular contact bearing.  These were about $10 each from VXB.  I did not take too many pictures during assembly, so here are some screenshots and renderings of the design.

Spinning Lead Screw Nut

Exploded view of the nut assembly.

Top view of X axis nut area

Top view of X axis nut area

 

http://www.buildlog.net/blog/wp-content/uploads/2014/06/Untitled-Project-30.jpg

Bottom view of X axis

 

Controller and Firmware

The controller is an Azteeg X3 with a Viki LCD.  I have used the X3 on a lot of projects.  It worked really well on this project because it has the on board SD card and works well with the Viki LCD.  The firmware is a highly hacked version of Marlin.  Here is what I changed.

  • Totally altered the LCD menu system to be right for a router.
  • Tore out all the temperature stuff.
  • Left in the extruder features in case I want to add a rotary axis.  I have used the extruder as a 4th axis successfully on other projects.
  • Added a Z zero touch plate feature.
  • Added a G54 machine offset like feature in EEPROM.  You you set a 0,0,0 for your workpiece, you can recall this later if there was a power failure or other crash.
  • The arrow keys on the Viki jog the machine.  In jog mode the up and down keys jog in XY.  The rotary encoder is still active and sets the rate of the jog, so you can jog XY in fast, slow and micro mode all from one screen.  Z can be jogged as well on it’s own screen.
  • There is a feedrate override feature on the main screen to speed up or slow down the feedrate.
  • All features are accessible via gcode, so pendant use is not required.

Homing and Work Offsets

The machine can be homed at any time.  The Z homes first at the top of travel before homing the X and Y so this is less likely a chance to hit a clamp.  Homing at the top of Z is not too useful for setting up your job, but the machine will now know the limits of travel and will never crash into the ends of travel.

The machine then homes at minimum X and Y.  There are also two other configured locations called “park” and “access bit”.  Park moves to center X, zero Y and top of Z.  The head is out of the way in this spot so it is easy to clamp the work piece in this location.  It is also has the minimum footprint in this mode for easy transport.  It also has an access bit location that moves the spindle to the front for easy access to change the bit.

You can jog and set a work 0,0,0 anywhere you want.  The machine resets it’s soft limits so jogging or G Code cannot crash at either end of any axis.  If you restart the machine, you can recall the last work 0,0,0 so a previous job can be completed accurately.

Feature List

  • Work area 12″ x 8″ x 3.5″
  • T Slot table (larger on all sides than the work area for clamping).
  • Sliding X table – Like a Bridgeport.
  • Spinning lead screw nuts.
  • Jogging with the pendant arrow keys
  • Z touch plate.  You can manual set the Z zero on the top of the workpiece or it can be done automatically with a touchplate.
  • X,Y,Z limit switches.
  • Park feature that moves the machine into it’s smallest size for transport.
  • Weight: heavy…about 45lbs
  • Soft limits.  If you set a new work zero, the machine still knows the new limits of travel.
  • Does not need a PC.  It can run completely off the SD card with control via the pendant.
  • No exposed wiring.
  • Super quiet DC spindle.
  • Cooling Fan directed on drivers, but flushes the whole interior.
  • “Park” command shrinks the size to smallest footprint to help with transport.
  • Freaking heavy at over 45lbs

Videos


To Do

  • It would be nice to have easy access the the SD card.  It is buried inside the unit now and you need to upload files to it via USB.
  • Add a real feed hold (immediate deceleration like grbl does now)

Changes.

  • There a few thing I would do to make it a little easier to fabricate.  A few holes were difficult to drill and tap and some simple changes would make that a lot easier.
  • I added an e-stop button since taking these pictures that cuts the DC power.

The Delta Router + 4th Axis

deltarouter

Overview

Every year I make a new thing for ORD Camp.  This year I made a delta router.  The ORD contraptions I make, have one primary function; to spark conversation.  This means they have to be interesting, a little whimsical and a little cool looking.  They are generally rather small for portability and to keep the costs down. Practicality and suitability are way down the list, so go ahead and snark away.  If you do, you are missing the point.

This year there happened to be a session on creativity with constraints.  The question we debated for an hour was, do constraints help or hurt the creative process. Constraints can move you out of your comfort zone and maybe that is a big part of creativity.  The topic was perfect for me because I had intentionally challenged myself with a few constraints on this project.

  • Use non captive stepper motors. Not a lot of people have seen these in use, they are cool to watch and they simplify the design.
  • Limit myself to 3 unique fabicated parts.  People keep thinking deltas are more complicated than .  This was to demonstrate the simplicity.  Go ahead, design a Cartesian machine with only 3 unique fabricated parts.  All other parts had to be commonly available parts.
  • Use stock reprap software.  I could only touch the configuration files.

Design

I met all the constraints except for one.  I designed a common top and bottom bulkhead, but at machining time I decided it was silly to to spend the time to add holes only used on the top to the bottom and the same with the top.  So the four unique fabricated parts are the top, the bottom, the carriages and the end effector.  The top and bottom are 3/4 inch Baltic birch.  The other fabricated parts are 3mm carbon fiber.  All parts were setup and cut in less than 30 minutes on my homemade CNC router.  A 3D STEP of my design is here.

Mechanicals

The vertical rails are MakerSlide.  I used steel V wheels because I had them laying around.  The rest of the mechanical parts are Actobotics parts from Servo City.  I thought they were an awesome discovery and then the next day I saw that Sparkfun started to sell them.  They really worked out great.  My only complaint is that they are imperial thread based parts.  I prefer all metric on my designs.

The non captive stepper motors are really cool.  The thread is a 2 start 8mm trapoidal, so it moves 4mm per rev.  They are quite fast and strong.  I custom ordered them at Robot Digg.  The only drawback is you cannot move them by hand.  You can’t spin the rod or the motor.  In this design they are a little vulnerable too.  If they get banged hard they could bend.

The linkages are Acrobotics heavy duty ball ends attached to some standoffs I got at McMaster.

Electronics

I used some mini arcade style switches for the limit switches.  They are pretty nice snap acting switches, but probably a little less accurate than microswitches.  I chose them because they would be super simple to mount without adding mounting brackets.

redbut

The controller is my favorite reprap controller; the Azteeg X3.

2014-02-09_10-17-20_373

Spindle

The spindle is a brushless DC hobby motor.  It is a Turnigy Trackstar.  The speed controller is a Turnigy Plush 30.  The shaft is 1/8″.  I used a simple shaft coupler to mount the bit.  This added a lot of vibration so the motor could not run at full speed, but that was OK becuase the full speed is close to 30,000 RPM and 550Watts!.  I eventually manually balanced the coupler and it runs a lot smoother now.  I did it by drilling through the existing set screw holes to the other side with a small bit.  I enlarged that hole until it was balanced.

balanced

ttsmn

 

TR-P30A

4th Axis

2014-02-09_11-48-11_382

Later when I got home, I thought it would be cool to add a rotary axis to it.  The challenge was going to be using the extruder motor logic for the rotary axis.  I had this attachment laying around that was bought from eBay a few months ago.  A typical 4 axis machine simply disables one of the axes while using the rotary.  That is not possible with a delta, so all 4 axes need to run at the same time.  It is quite fun to watch.

rotary_attachment

 

It was perfect because it was so small.  It has a 6:1 reduction gear inside.  I made a simple base for it that would allow it to be quickly mounted to the router.

rotary_base

 

Firmware Changes.

The firmware changes to Repetier were pretty simple.  Extruders use millimeters as the feed unit, so I just converted that to degrees.  The motor is 200 steps/rev with 16x microstepping plus 6: 1 gear reduction.  This yielded 53.333 steps per degree.   I changed the safe extruding temperature to a very low value and then just wired a 100k resistor across the thermistor pins so it read a constant value above the safe temperature.

 CAM Software

I don’t have any high end CAM software that does anything really cool on a rotary.  I did have an evaluation copy of DeskProto, but that timed out.  I did have Vectric V Carve that does have a wrapped rotary feature.  That would be good enough to do my Hello World project.  I had to write a post processor for it.  I basically hacked the Mach3 wrapped rotary post processor.  I had to make it really simple and tell it convert “A” moves to “E” moves.  There were a couple other changes too. The post processor is here.

hellopath

Changes and Issues

  • I really need a tail stock to support the stock and help set up the job level.

tailstock

  • The feed rate on rotary axes are tricky because millimeters per minute is quite different than degrees per minute and there is no way to deal with that in GCode.  The actual feed rate through the material depends on the radius (Z).  Programs like Mach3 can compensate for it.   I could really hack the firmware or maybe write a post post processor to compensate the speed based on the Z.
  • I need to get some real software to some interesting carving with this thing.

hs

First Job Video

Go Deltas!

 

vld