If you have done any extensive poking around the Grbl source code you will eventually come across this line in nut_bolts.h.
#define N_AXIS 3 // Number of axes
It would be so easy to just change that to 4 or 6 and have some fun, right? No, unfortunately it is not that easy. With a little work though, it is not too hard to add those extra axes to Grbl. I decide to try this with my PSoC port of Grbl.
Typically the axes after X,Y, and Z are labeled A,B, and C and are often rotary axes. Here is a simple 4th rotary axis.
Things get more complicated when you add more axes. Here is an example of a 5 axis upgrade for a 3 axis machine.
While simply changing N_AXIS does not suddenly make the extra axes work, it does do a lot of the work. I found it used over 80 places in my port. It will do virtually all of the major code work. I just needed to do the following…
Read the ABC parameters in the gcode.
Add additional $$ settings for steps/mm, speed and acceleration for the A, B, and C axes.
Add homing code for A,B, and C.
Adds some #define statements to make it easier to configure between the axis counts.
As I was working on this I stumbled upon a few other people working on this. This code I found was especially helpful.
Grbl uses 1 byte byte each for axis step, direction and limits switches. Those bytes are used with a mask (to say with bits are actually used) and applied directly to an I/O port. This is a very efficient way of doing it, but it forces you to put all axes on one I/O port for each of the step direction and limit switch functions.
My port to PSoC uses Control Registers to output the step and direction signals and Status Registers to read the limits switches. These registers can be ‘wired’ directly to I/O pins. There are several advantages to this, but the main ones in this context are, you don’t need to map them to the same I/O port and you only have to connect the ones you want to use. Here I have defined all 6 bits on the Control Register, but have only connected the I/O pins I am using.
To make the PSoC port easier to maintain as Grbl changes, I did not change the Grbl method to much. The mask is still applied, but the mask is hard coded.
The homing switches work in a similar fashion. Here is a 4 axis setup.
The storage of the steps/mm, speed, and acceleration will increase the amount of EEPROM required. The PSoC has plenty, but keep in mind every time you change the axis count, you will need to reset the EEPROM because the locations will get shuffled and the restore from EEPROM will not work the first time you start under the new axis count.
The status is going to report the extra axes, so I assume it will break a few senders.
Sending the GCode is pretty easy, but I don’t know of any basic gcode senders that support more than three axes.
My personal sender uses regular expression to do the basic parsing of the status. This is a robust way to to handle status that can change formats as long as it is predictable. I send the position data to a function that splits it into a string array. I’ll just need to add some DROs for the extra axes if it detects them.
I don’t have a 4 or 6 axis CNC, so I built a little test rig with 6 axes. I used a Gecko G540 and 2 single axis drivers. Each stepper has it’s own home switch triggered by a cam on limit switches with roller actuators. This allows the switches to be triggered , but allows the steppers to run continuously in either direction. The homing sequence is quite fun to watch. Building this test rig took about as much time as the firmware changes.
I want to do a lot of testing, then build a machine to do some real world testing. I currently don’t have any decent CAM software over 3 axes, so I will need to deal with that. I will then add it to my GitHub repo for this.
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.
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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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 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 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.
Find T3 using the Law of Cosines. We want the left one of the two T3 angles, but since the linkages form a parallelogram that same angle shows occurs in several places. We will use the right one and the dimensions associated with it.
Determine A1 and A2 from the angles we figured out.
A1 = T1 + T2
A2 = A1 + T3
I think I will switch the code to use this method. I think I can optimize it better in C code. The speed of the code is important. The faster it runs, the most times per second we can run it. The more often we run it, the smoother it will run.
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.
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.
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
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.
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.
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.
A Gonzo Build is something we came up with at Pumping Station OneCNC 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.
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.
Portable dual 24V/48V power supplies with master power switch.
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.
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.
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 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..
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.
Exploded view of the nut assembly.
Top view of X axis nut area
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.
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
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)
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.
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.
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.
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.
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.
The controller is my favorite reprap controller; the Azteeg X3.
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.
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.
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.
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.
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.
Changes and Issues
I really need a tail stock to support the stock and help set up the job level.
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.
I need a tiny spindle for a CNC Build Club project I am working on. I decided to use a Brushless DC Hobby motor. These motors have a huge amount of power for their size and cost. I want the machine to be able to turn the spindle on and set the speed via GCode so I spent some time testing this out.
You need to power these motor with special 3 phase controller. These are typically controlled like a hobby servo, so the interface is a little different than a typical spindle motor. The machine is going to be a delta type machine, so I will be using RepRap firmware. Marlin was selected over Repetier because it has built in servo control.
The motor is a Turnigy Track Star motor. I like it because it is sealed and air cooled and it is 550W. That is over 2/3hp.
This is the Brushless Electronic Speed Control (BESC) I used. It is a Turnigy Plush 30A. It has a battery eliminator circuit, which is basically a 5V output to eliminate the need for a battery for the RF receiver and servos. This is the thin red wire on the 3 wire connector. This should not be used because the Arduino has it’s own 5V supply.
Hobby servos use pulse width to control the position of the servo. You basically use a pulse from about 1ms (off) to 2ms (full speed) to control the servo. This must be repeated about every 20ms.
The BESC has a safety feature where you must turn it on in a special sequence. You must set the pulse length to minumum (1ms), turn on the motor power supply, wait until you hear the startup beeps, then a few more beeps which tell you the count of batteries connected. You can then vary the pulse length to control the speed.
Basic Arduino Control.
The first thing I worked on was basic manual control using an Arduino. I started with the “Servo…Knob” example that comes the Arduino IDE. I modified it a bit to match the pins I was using. It reads the voltage on a potentiometer and uses the value to set the pulse length. The sequence was, turn the knob to the minimum, turn on the power supply, wait for the startup beeps, then use the pot to control the speed. At first it did not work. I looked at the servo library code and found it used 540 microseconds for the minimum pulse and 2400 microseconds for the maximum pulse length. I switched from myservo.write(val) to myservo.writeMicroseconds(val) to use the actual time values and it worked.
Here is the code.
// based on the servo...knob example.
// define the min and max because the servo library has a wider range
#define MIN_PULSE 1000
#define MAX_PULSE 2000
Servo myservo; // create servo object to control a servo
int potpin = 0; // analog pin used to connect the pot
int val; // variable to read the value from the analog pin
myservo.attach(3); // attaches the servo on pin 3
val = analogRead(potpin); // reads potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, MIN_PULSE, MAX_PULSE); // scale between 1ms and 2ms
Serial.println(val); // show the values
myservo.writeMicroseconds(val); // sets the servo using microseconds
delay(20); // wait a bit
Automatic Startup Using Arduino
The next step was to try semi-automate the startup sequence. In the previous step, I found that holding the pulse to the minimum length for about 4 seconds was long enough. This code would test that. After startup the Arduino output the minimum pulse, lit an LED as a signal to turn on the power supply, then wait for 4 seconds.
// based on the servo...knob example.
// define the min and max because the servo library has a wider range
#define MIN_PULSE 1000
#define MAX_PULSE 2000
Servo myservo; // create servo object to control a servo
int potpin = 0; // analog pin used to connect the potentiometer
int val; // variable to read the value from the analog pin
int led = 13; // led pin
pinMode (led, OUTPUT);
myservo.attach(3); // attaches the servo on pin 3 to the servo object
delay(1000); // wait a bit for the human to get ready
myservo.writeMicroseconds(MIN_PULSE); // go to the low end
digitalWrite(led, HIGH); // signal p/s turn on
delay(4000); // wait a bit
digitalWrite(led, LOW); // ok to control with pot
val = analogRead(potpin);
val = map(val, 0, 1023, MIN_PULSE, MAX_PULSE);
The plan was to use the servo control feature to adjust the speed and the heater control circuit to control the power. Here are the changes I had to make to Marlin. Search for these lines in the files indicated and change them.
Overview: The temp sensors are all disabled. You need to remove HEATER_BED_PIN from the array of SENSITIVE_PINS or the M42 command will ignore it. Setup what pin you want for the servo output. I changed the default pulses to comply with what the BESC wanted.
in file pins.h
#define SERVO0_PIN 31
remove HEATER_BED_PIN, from SENSITIVE_PINS
in file servo.h
#define MIN_PULSE_WIDTH 1000 // the shortest pulse sent to a servo
#define MAX_PULSE_WIDTH 2000 // the longest pulse sent to a servo
#define DEFAULT_PULSE_WIDTH 1000 // default pulse width
I used Repetier host to talk to the controller. Here is the GCode I used to test. It runs the motor for 10 seconds.
; set speed to zero
M280 P0 S0
; power up speed controller
M42 P8 S254
; wait for startup tones
; go to full speed
M280 P0 S180
; run for 10 secs
; turn speed to 0
M280 P0 S0
; turn off power
M42 P8 S0
It turns out I was not able to get the bed heater circuit to directly control the power to the BESC. The bed heater circuit switches the ground side of the the circuit and the positive voltage is always present. The controller would not turn off. It was using the servo ground wire, which is probably not rated for that. I had to find a way to switch the positive voltage.
The easiest way to do this was with a relay. I wired an automotive relay to the bed circuit. I put a flyback diode across the relay to protect the bed heater circuit. It all works perfectly now.
12-/27/2013 I tried hooking both grounds to the heater power circuit and it pulled ground from the servo signal pin. That can’t be good for the BESC or the CPU, so back the the ugly relay.