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.

Feet.

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.

Handle.

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.

Scaling

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.

Prototyping

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.

Source

You can get the source files at Thingiverse.

I have developed an inexpensive control system (less than $70) that can be used to both get more cutting power out of a DC discharge laser and significantly improve cutting accuracy for home built laser systems.  The control system implements a control technique known as Pulse-Per-Inch (PPI) control.  PPI control involves pulsing the laser every time the head travels a certain distance.  PPI control allows a CNC laser to produce consistent cuts at the same power level setting over over a wide range of speeds.  In effect, pulsing the laser as a function of distance along a cut decouples the power input to cut from the speed that the head travels.  Therefore, the speed and acceleration of the CNC system have minimal bearing on the cut characteristics.  Furthermore, the unique transient rise response of a DC discharge laser allow PPI to deliver more power to a cut in comparison to the same laser system with just on/off control.

Background and Motivation

A while back, I was active on a forum in which we were discussing the time it takes to turn a laser on and off and how that relates to engraving control.  One of the forum members from Full Spectrum Engineering posted a high-speed intensity spectra for the cheap DC discharge lasers that we use for DIY laser cutters.  I was quite surprised by the spectra.  I expected to see a nice exponential rise to set power level, but what we saw was a rapid rise to a very high power level (nearly double the set value) followed by an exponential decay to a set value.  The Spectrum in question is shown below (credit for the spectrum rests with Full Spectrum Engineering).  The yellow square wave is a 5ms pulse sent to the laser power supply.  The green spectra is the intensity spectra of the laser.  For whatever reason, the magnitude of the spectra is upside down (I think the ground and signal leads were reversed), so on for the digital signal and higher intensity for the laser power spectra are down rather than up.  Anyhow, the spike in intensity is caused by the necessity voltage to start a plasma in a DC Laser.  The laser power supply generates a very high voltage to start the plasma which is stored in a capacitor.  When the signal comes to turn on the power, the power supply dumps this charge into the system and then supplies a nominal (still very high) voltage to sustain the plasma once it is on.

DC Discharge Pulse

The spectra got me thinking about a PPI control system that Ben Jackson, another member of the forum, had implemented with EMC.  PPI control is used by big companies like Epilog and others for vector cutting.  The thought came to me that a short pulse of 2-3ms would result in an average power output that was significantly higher than the output of a constantly on system.  Further, the duty cycle is generally much lower which will allow the laser to operate much cooler.  This allows a DC laser to effectively operate at much higher power levels than it is rated for without causing damage to the system.

There are also accuracy benefits to using PPI control.  To get great results with vector cutting, one has to very tightly control the power density going into the material no matter where the laser head is or what its velocity, or acceleration is.  If this is not done, one can get very inconsistent results.  The inconsistencies are mainly related to power density variations causing variations in kerf width and/or overheating materials which cause charring/melting/burning.  When a CNC machine encounters a corner or a sharp curve, it has to adjust the speed of the head to smoothly accelerate into and out of the curve or corner.  For laser systems, there is no tool pressure and the head is fairly light so the accelerations are very fast and almost unnoticeable.  Even so, the time it takes for a laser to cut/expand kerf is orders of magnitude faster than the time frame needed for acceleration.  This means that tight control of the laser at all times during a cut is needed for the best results.  Perhaps the most noticeable problem most people encounter with a home built laser system is what looks like a tiny drill hole at the start and stop of a cut.  The problem is particularly noticeable for those who use standard CNC software (like Mach 3 or EMC) to control the laser and is caused by a delay in the control system when it processes the on/off command before/after motion starts/stops.  The delay is only on the order of ~5-10ms or so (almost unnoticeable), but that is enough for the laser to expand the kerf as it sits stationary.  Lead in and lead outs can help this problem, but one does not always have room for the lead in with certain parts or there may be so many cuts in a file as to be impractical.  An example would be a scroll saw pattern.  A CNC laser is ideal for this kind of artwork, but the drill hole at the start/stop of a cut can be visually unappealing and adding lead in/outs for thousands of cuts is quite tedious, if there is even room to do it.  There are relatively inexpensive laser controllers out there (FSE and DSP) that have better laser control and eliminate this, but they range in price from $400 to$500 and they can’t handle g-code files.  Further, for engineered parts, the tolerances can be improved by a constant kerf width at all times.

Epilog Elite Series Lasers www.epiloglaer.com

It is for these reasons that the “big guys” in the industry use PPI control for vector cutting.   By pulsing the laser as a function of the distance traveled, it strongly couples the sum power applied to the material being cut to distance along the cut path rather than the time the laser is on.  This decouples the power density from velocity of the head, which is key to achieving consistent cuts.  If the pulse were instantaneous, there would be no coupling to velocity in this method as long as the laser could supply the frequency and the power level needed to make the cut.  In reality the pulse has a defined time width which means that the travel velocity does affect the cut, but to a much lesser extent.  In this way, a great number of discrete events produce a high quality cut which are almost completely decoupled from the time derivatives of position.

Control Strategy

To do this, one has to accurately know the position of the laser head at all times.  Without going to the lengths of installing a linear encoder on the axis, one can do this by tracking the pulse and direction signals to the stepper motor drivers.  This could be done in the motion control software (ex: Mach 3, or EMC).  However, this strategy places extra computational burden on the controller and can lead to inaccuracies if the controller does not operate in a truly real time fashion or if there are real time delays.  Further, one would need a differently developed solution for each controller which is a lot of work and may not be possible in every case (such as with the light object controller).  However, every controller has to produce a step and direction signal in the same way which get sent to a stepper driver, so this is a good place to track position from as it is universal and truly real time.  In my case, I use Mach 3 with a USB Smooth Stepper (SS).  The SS is capable of producing step pulses at about 2 MHz which is significantly faster than most common controllers that use a parallel port.  With the standard setup of a 2.X system with 0.9^o steppers and 16x micro-stepping, a 2MHz pulse rate amounts to about 70 m/min travel speed.  This is faster than I really ever run the system now, but these are common speeds for engravers that are higher power than my machine.  I have a 40W system and will likely upgrade to a higher power source as I start to develop an engraving solution.

There are a couple ways to count pulses this fast.  One can use a micro-controller (MC) directly or dedicated set of binary up/down integrated circuits (ICs) with a MC.  To use a MC directly, one would have to be able to pole the pulse and direction the signals at a minimum of 4x faster than the signal frequency.  That means about 8 MHz in my case.  For most common MCs, it takes about 20-50 machine code lines to read an input pin, do a basic comparison/calculation, and set an output pin (or set of).  One could also use a pin based interrupt to do the counting.  However, at 2MHz pulse rates, this means that there are fewer than 8 machine code lines between pulses to do any operations related to the math it takes to set the pins as well as actually setting the pins.  This is simply too fast for a single core MCs to keep up with running at sub-GHz speeds and expect the MC to be able to reliably do anything else but simply indexing a counter.  To make this feasible with cheap and easy to use MCs (like an AVR/Arduino), one has to alleviate the counting burden from the MC (ie: using a set of ICs to count for the MC).  Fortunately there are many MCs that are cheap and have a plethora of digital IO to read the 17 & 16 bit binary numbers produced by the ICs to count all the pulses on the x & y axes respectively.  As long as the MC can execute its loop through the calculations to set the laser within a 500 microseconds, then everything is alright.  The MC is free to pole the counter signals at will and at the time it checks it, the position is guaranteed to be real time and up to date (as long as the ICs are rated for faster clock speeds than the stepper pulse rate).  The MC can then act on that information however it needs within a few (to tens) of microseconds (depending on your code efficiency), which is plenty fast enough as the laser can’t even turn on within 500 microseconds.

Hardware/Software Implementation

Now that the control strategy is understood, I will move on to how this is implemented in hardware and software.  The hardware is fairly simple and cheap.  The heart of the IC counter is the MC14029B by ON Semiconductor.  I got them from digikey for about $0.70 a piece.  They are 4 bit  binary/decade up/down counters with a reset and direction pin and have a carry in and carry out pins so they can be linked in series to make larger counters.  To count all the pulses at max micro stepping, it will take 17 bits on the x axis and 16 bits on the y axis.  As an aside, one doesn’t need to count all the pulses and could probably get away with an 8 bit counter, but I want to use this setup for engraving as well which means I need absolute position tracking and not relative, so I went ahead and made the counters big enough to count all the pulses.  That means I need 5 on the x and 4 on the y for a total of 9.

Binary Counter Circuit Diagram

The ICs are through hole and have sockets on the board.  The pin headers are 26 pin and 34 pin on 0.1” pitch.  This allows a common ribbon cable to connect to the board.  The power terminals are screw terminals.

The 26 pin header is used to listen to the incoming step, direction, and limit switch signals that come across the 25 pin parallel port from the CNC controller.  The SS comes with a 26 pin ribbon cable that is terminated in a 25 pin D-Sub connector.  I put a 26 pin IDC connector in the middle of that cable to connect to the header on the left side of the above figure.  I actually recommend that people “snoop” this way.  It was the cheapest way to gain access to the signals without cutting the lines.  Two 25 pin D-sub connectors and a short length of ribbon cable can be purchased for about the same price as a regular 25 pin D-sub cable.  You lose shielding, but I found that you don’t need it.  The stepper pulse from each axis goes to the clock of each IC.  The direction signal is tied to the up/down line, and the limit switch is tied to the reset pin.  The input pins for the reset value are tied to ground so that each time thel imit switch is hit, the counters initialize to zero.  There are a total of 35 pins to read for input from the counters plus one pin to read for the laser signal for a total of 36 to pass to the MC.   The circuit can be routed onto a 2 inch by 2.5 inch board.

Example Hardware Layout

I chose to arrange the output pins in order to make troubleshooting easier and the board layout simpler.  However, that means that the cable coming from the board needs to be rearranged so that the output pins meet up with ports on the MC in a logical manner.  The port/pin arrangement for each MC is different and will require a cable to match, but that is relatively easy.

Counter Board Installed

The proto-board is significantly larger than a PCB would be, but it fit just fine anyhow.  I am very glad that I built a proto-board first because I had originally tied the Binary/Decade pins to high rather than low as I misunderstood the datasheet.

The MC I chose to use was an Arduino Mega.  I chose this because I had it laying around and it had enough IO to read the pins, not because it was particularly optimal for the design, though it was more than sufficient.  I mounted the board on the underside of the LPS shelf so it would be out of the way.

Mega/PCB Cable Connection Table

The quickest way to read a large set of digital pins is to read an entire port at once.  This only takes one machine code line.  The Mega has groups of 8 pins per port, which means that I have to read a minimum of 5 ports to get all the information.  Newer MCs (ARM based) have 16 pins per port, which means one would only have to read 3 ports.  The strategy here is to group the binary pins in order so that they only have to be bit shifted and added to make the large number.  The following table shows how to order the pins for the cable to connect the hardware to the Mega.  I have a pin crimper so I split the wires apart, stripped the ends and put them into 0.1” pitch pin holders to connect the pins to the board.

If you have been following my buildlog, you would see a difference in this order in that I originally had the laser set tied to pin 13, but this would make the laser flash on reset and data transfer because pin 13 is also tied to an LED on the board that flashes with those events.  To keep the laser off and safe, I switched the pin to 12.  Also, you may be wondering why I didn’t use all of B for an input for Y.  First, there is the pin 13 issue, but also I wanted to use an output that wasn’t tied to the X axis group to switch the laser on/off for engraving.  Further, the physical grouping made this easier.

So now let’s discuss the code.  The first thing to check is if the laser cmd in pin is high.  If it isn’t, the laser set pin is set to low.  If it is on, the next thing to do is check for motion.  If the head is moving, proceed.  If it isn’t, the MC will set the laser to off.  If there is motion and this is the first time through the loop that the laser pin went from 0 to 1, then immediately set the laser to on and start the timer.  When the timer reaches a given time, the MC will set the laser back to off.  Now the MC just calculates the distance since it set the last laser on state.  When the distance is greater than a given value, it will reset the timer cumulative distance value to zero.

The code can be found on my github sit:  DirksGitHub

Testing

With that, the control system is functional, so let’s talk about some results.  I set up some tests to cut paper.  I wanted to use paper because it is notoriously difficult to cut well with traditional means.  It is very thin so if you heat it too much, it can easily catch fire.  However, with a pulsed cutting system the heat is managed and this is not a problem.  Further, any overheating is magnified as poor quality cuts.

PPI Test 1

I set up 3 tests which would show the results of varying the PPI setting, the feed rate, and the pulse width.  First, the PPI was varied from 25 to 800, doubling each test.  The cuts were 1 inch long , the pulse width was set to 3ms, and a constant feed rate of 400mm/min was used.  You can see that it is actually calibrated correctly.  There are 25 spots cut into the 25 PPI line.  There should be 26, but it is likely that Mach 3 didn’t give the final pulse needed to get the last laser pulse to switch on or that the number of pulses per inch is slightly off in the MC program.  There is probably a way to fix that in the code, but for higher PPI settings, it doesn’t matter if one pulse is missing at the beginning or end.  The 50 PPI setting is indeed double the pulses and they line up well.  The 100 PPI is just barely continuous and the individual dots just barely overlap.  That means that the laser spot is about 10 thousandths of an inch across.  I might be able to do a little better if I turned down the laser power and worked a little harder at finding the correct focus, but that isn’t bad for paper.  The 200 PI line is the first one that looks to be continuous.  The 400 and 800 PPI lines look progressively smoother, but get wider as the PPI increases.  You can see there is a little disturbance in the middle (particularly noticeable in the 800 PPI line).  That is the result of one of the cross-members in my table.

PPI Test 2

The second test was to vary the feed rate while keeping the pulse width and PPI constant.  The image shows the results of varying the feed rate between 600 and 8000 mm/min.  The pulse width was set to 3ms and the PPI was set to 50.  The lower set shows the feed variations between 600 and 4000 (actually, between 400 and 4000, but I wrote over the first line by accident).  You can see that the 600 to 1200 look to be identical.  The rest of them up to 4000 seem to be a bit off with the endpoint.  They have the same number of pulses, but the endpoint (right side of the line) seems to be shifted in length a bit.  I don’t think this is a problem with the controller, but the result of backlash in the mechanical system.  I will have to look into this further though.  I have noticed variations in my parts up to about 20 thousandths so this may explain some of this.  I suspect that the backlash is coming from an imprecise mate between the drive sprocket and the toothed belt.   It may not be hard (or expensive) to make this system into a servo based system.  Epson printers use an encoder filament strip with a LED/phodotiode set to control the position of the print head.  It should be possible to use a system like this to provide feedback to the stepper controller or completely replace the steppers with a DC motor drive with an H bridge motor controller.  Either of these strategies will compensate for position inaccuracy.

PPI Test 3a

The last test was to vary the pulse width and keep the feed rate and PPI the same.  The feed rate and PPI were set to 400 and 50 respectively.  The lines in PPI Test 3a are pulse widths between 1ms and 10ms.  1ms is too short to cut through the paper, but it does mark it.  2ms results in a cut, but very fine.  3 and up cuts with progressively larger diameter and darker, but they don’t show much evidence of smudging (that is the holes seem to be round).  It’s hard to say, but the 10ms line may show a bit of smudging starting to happen.

PPI Test 3b

The bottom 9 lines in PPI Test 3b progress from 20 ms up to 180ms by 20ms intervals.  The top line is 1000ms and is basically full on.  The 40ms line happened to be right on top of a cross member in my table which reflected the light and burned it out unevenly.  The second half of the line was fine though.  You can see definite smudging in the dots.  At 80ms, the dots are fairly well connected.  Any longer time has fully connected dots.  The kerf width gets quite a bit wider and less uniform.

While this test is informative and demonstrates the effect of longer pulses, there is no need to use a pulse width longer than 3ms.  2ms may be better.

There also seems to be some inconsistencies in producing the first and last pulse.  This isn’t very concerning though.  Missing the first or last pulse in a cut with a high PPI setting doesn’t amount to much.  That said, I will work on fixing the code so that this doesn’t happen.  The big thing is that the laser is not on when the head isn’t moving.  If there is an error, I would prefer that the error falls on missing a pulse rather than producing an on signal when the head isn’t moving.

Scroll Saw Art Present for My Sister

I developed this control strategy to do scroll saw work and make Christmas presents for my family and friends this year.  The control strategy allowed me to avoid the drill holes, use a free control program (lazy cam) to produce the g-code as I didn’t need lead in/outs (which allowed me to keep my sanity as well as there was about 500 cuts to make).  As a matter of record, the lower whisker in the upper group on the right side thins out to about the thickness of a piece of paper.  Without this control strategy, I couldn’t have cut that.  The edges also turn out with a very nice light brown color.  This is 1/8” baltic birch plywood.  I found that the best settings are 400PPI, 400mm/min, 3ms, and 100% power.   The PPI setting to get a continuous cut is much higher for thicker materials because the kerf at the bottom of the cut is significantly narrower than at the top.  I understand that this is in part due to self focusing of the laser in the kerf.  Too much lower PPI results in non-continuous cuts.

Test Summary

The PPI implementation worked very well with the exception of occasionally missing the first and last pulse which will have to be investigated.  This problem is not noticeable with high PPI settings (high enough to create a continuous cut).  Cuts using PPI are much more controlled with uniform kerf and no burn in and burn out marks when the laser head starts and stops.  Further, tests in wood show that the amount of burning in the cut is much lower and the sides of the cuts are much lighter.  That said, there is a certain amount of roughness on the sides of the cut with lower PPI settings.  With high PPI settings, this is barely noticeable.

Future Work

Cyber Cortex (www.fabuloussilicon.com)

So where do I think this will go?  I think this will migrate to an FPGA controller.  There are several FPGA based controllers on the market for very little cost.  Bart Dring told me about the Cyber Cortex AV by fabulous silicon.  FPGA’s are amazing!  You can basically program the controller to be any transistor based IC you want.  I could fit the whole counter board developed here and 3 or 4 Arduino’s on one chip.  I will eventually migrate this project to the Cyber Cortex and implement the engraver on that as well.  I currently use another Arduino Uno to do modbus IO for the system.  That can also get rolled into an implementation of an FPGA controller.  This means that the open source community could have a PPI controller, an engraver, and a modbus IO for under $150.  As I make progress with this project, I will continue to post results and make the code available to anybody who wants it.

Acknowledgements

I would like to thank Bart for providing the opportunity for me to share this bit of work with the great user community we have here at buildlog and also for giving us such a great base of a CNC laser system to have a bunch of fun with.  I would also like to thank Ben Jackson for giving me the idea to use binary up/down counters and for reviewing some of my design work.  Finally, I would also like to thank my friend Justin Weber for being a sounding board for my ideas and for being just an overall great friend.

Buildlog.net Editor’s Note

Thank you to guest blogger Dirk Van Essendelft for this post.  Dirk is a Chemical/Biochemical Engineer from Morgantown, WV.  Outside of his work as an research scientist for the National Energy Technology Laboratory, Dirk has interests in woodworking, robotics, CNC Machining , and model building.

There has been a ton of interest in camera slider applications for MakerSlide.  A while ago I decided to make a very simple reference design for a motorized slider.  This design only required fabrication of one part.  The rest of the parts are existing components.  The part can be made on a laser cutter, router or even by hand.  There are no tight tolerances and you can use the MakerSlide carriage as a template for drilling some of the holes.  I can sell a complete slider system including motor for less than $120 for a 1 meter setup.  It would only be $10 for each addition meter.  The longest I can ship is 2.5 meters, but I stock the material in 4.5 meter lengths if you can figure out how t0 get it.

I don’t know much at all about this type of camera work so I did not see all this interest coming.  Several people approached me about buying my prototypes and I have sold several of them.  Most of them asked me how to control the motor.  I come from a CNC background so most of my demonstrations were done using CNC software like Mach3, EMC2 or even GRBL.  This has few issues.  The first is many photographers have no knowledge of CNC or G-Code.   The second is the solution is way overkill in cost and complexity for a single axis machine.  The third issue is portability.  This will probably be used in the field where a PC is impractical and power may be unavailable.

I decided to make an Arduino based controller.  Arduinos are good because they are cheap, small and easy to program.  They also use very little power.  I wrote a similar controller for the PIC processor a long time ago and borrowed the basic algorithm from that.  The method used could work for multi-axis machines if you want to steal the code.  The Arduino is. using my Stepper Shield.  I have just one driver installed and in another “slot” I have a bread boarded switch.  The stepper shield is nice because it can act as a mother board for many future features.

MakerSlide: Camera Slider Control Program 2011 CC-A-SA

0 = Set Current Location as 0
S = Stop now!
D = Disable Motor
E = Enable Motor
H = Home (Move to 0)
M = Move to ..(M Dest Speed Accel)
J = Jog until stopped ('J 1' for forward, 'J -1' for reverse, 'J' to stop )
I = Info (show current parameters)
G = Go (start program)
P = Show Program
C = Clear Program
L = Edit Line.  Format: L Line# Dest Speed Accel)  Ex: L 0 2000 3000 1500
      Use 0 for destination and speed to indicate end of program
      Use 0 for speed to indicate a pause.  Dest is pause in milliseconds
R = Set Max Speed
A = Set Max Accel
V = SaVe to EEPROM
? = Redisplay this menu

The controller uses a menu driven interface via the USB connection.  The easiest way to talk to it is though the Arduino IDE serial monitor.  That allows a free, common interface between PC, Apple and Linux,  but most serial terminals would work.  The commands currently work in the unit of stepper motors steps.  It could be easily converted to a real world unit, but at this time it is just easier to use the same unit that the motors use.  My system has 4000 steps per inch.  That makes for a very smooth system.  Extremely slow rates are possible.  It can go 1 step per second at 4000 steps per inch, so it could take well over and hour to go an inch.  You could hack the code to easily drop this by many orders of magnitude.  Each move can have its own speed and acceleration to fine turn the affect you want.

It has several commands to interactively move the carriage around.  This would probably be done to setup the system before the actual “shot”.  These include Move, Home (go to zero), Jog and Zero (define current location as zero).  You can also create a move program.  This allows you to define a couple dozen moves that run sequentially.    These can either be moves or dwells (pauses).  Once the program is entered it can be saved.  This allows you to pre-program the device before you take it in the field.

At power up the motor disables.  This allows you to slide the carriage by hand.  This is handy if you don’t have a PC to do it in the field.  As soon as you make any move or run a program the motors enable.

How it works (programmers only)

The controller uses a timer to run an interrupt function at a regular interval.  The default is 40,000 times per second, but that be be tweaked by changing one program line.  The interrupt function determines if a step should be taken.  If you want to move at 20 steps per second, you allow the interrupt to run (40000/20) or 2000 times before the step is taken.  A counter in the interrupt counts up until it is time to step.  By varying the count on the fly you can create smooth acceleration.  All the math required to smoothly accelerate could limit the interrupt rate, so  the calculation are done once, before the move occurs.  Inside the interrupt is all simple integer counting and a few tests.

Source code (Arduino 1.0)

Wiki Page on Slider

Wiki Page on Software

Buy one here at the MakerSlider Store

Future Plans

I have several features I want to add.

• Android smart phone control via the Arduino Mega ADK
• USB shutter control of cameras.
• CHDK control of Canon cameras
• IR remote control for the shutter.

Drawbacks

Stepper motors draw a lot of power.  I was running my NEMA 17 at 11V and 0.1 amps.  You need a decent battery of 2000-3000 mAH to do a multi-hour run.  Steppers are also notoriously loud.  The camera will  pick up the noise if the mic is close the the motor like on the camera itself.   The motors I have are way over kill and running at less than 10% of their rated current.  I have some NEMA 14 motors on order.  Servo (not hobby servo) motors would be a lot quieter but and lower power, but are more complicated and might require gearing down.

Comments: feel free to comment below or on this forum thread.

Videos

A guy I met at WorkShop 88 is putting together a Maker Faire like event through the local ASME group. It is called the “AMSE Open Source Microcontroller Workshop“. He wants to get a bunch of local open source people to show off their machines and electronics. If you are interested in a meet up, stop by. I can probably get a few free tickets.

I agreed to go, but I don’t like hauling my laser around because I might break something. I have a second laser build going to test the MakerSlide changes. This will be fully functional except for the tube and tube power supply. It will also be run via Mach3 rather than an expensive controller.

The only problem with Mach3 is that you need to haul around a complete computer, with keyboard mouse and monitor. I am already bringing my laptop, so I was trying to figure out a passable way of using that. I know there are options like SmoothStepper and PCMCIA (rarely works) parallel ports, but I did not want to spend any money just for this event.

I have a very small desktop computer with a parallel port. I decided to try putting a VNC server on that computer to see if the laptop could be the display, keyboard and mouse for Mach3. I have used several flavors of VNC, but have found UltraVNC to be my favorite. VNC stands for Virtual Network Computing, but a better description is remote control software.  You basically get to control the desktop of a remote computer.

I installed it as a service so that it would be available as soon as possible. I already had the computer setup to boot right into XP without a login. The server computer did not complain at all about not having a keyboard attached.  I gave that computer and my laptop different static address on the same subnet.  I connected the two computers with an Ethernet crossover cable.  Once the VNC server (the Mach3 computer) booted, I connected with the viewer software from the laptop.

It connected fine and I was able to start Mach3 and run the laser.  It worked quite well and the display update rate was acceptable, even on the DROs.  The only issue I found was arrow key control of the axes was rough.  It took me a little time too figure out the problem.   The axis would start up fine then start to stutter a bit.  I think it worked fine until the key went into auto repeat mode.  If you hit the tab key to bring up the pendant looking thing, you can use the mouse to move the axes quite well.

I also hook up my Shuttle Pro and that works so much better than arrow keys any way.

Running G-Code worked perfectly.  It is not a permanent solution, but it met my goal of not spending any money.  It could also work as a simple remote monitor on a running job.

Pololu stepper drivers are great little items.  They are inexpensive and very easy to use.  You only need a step and direction signal to control them.  If you use them in sockets, as I show here, they are portable between projects and experiments.  If you accidentally smoke one, you only need to replace the single driver.

There are a lot of carrier boards for these.  There are Arduino shields and many other applications.  Often, it would be nice to be able to drive a larger external load like a spindle or blower.  You can then use the existing step and direction signals to drive the relays.  It uses the voltage normally used to drive the motors for the coil voltage.  The only wiring required is two wires to the relay.

I chose to put the relays off board because the real estate was pretty limited and I wanted to provide the voltage isolation for AC powered devices. I am also a big fan of DIN rail mounted relays. They are very reliable and inexpensive. They are easy to swap around and have some nice features. The relays shown have a LED indicator and also a manually test button that moves the contacts. The relays shown are about $10 each, including the DIN rail sockets.

I got the boards from Gold Phoenix in 2 sheets of 50. They were not cut out, only V scored. Fortunately I have access to a depanelizer at work and was able to easily separate them. I probably could have snapped them apart too. The depanelizer looks similar to this one. Two slowly spinning sharp disks chop them apart.

The boards have all the components required to drive the relay including a supression diode. I am using a pretty hefty transistor here, but you could substitute a smaller one.

Schematic (PDF)

Gerber Files

One of the worst jobs with the 2.x Open Source laser is the hardware kit.  I hate counting out all the parts.  Some of the part counts are like 150+.  The MakerSlide reward kits have a lot of parts too for the wheels and spacers, etc.

I finally decided to get a part counting scale.  Essentially what this scale does is weight things in part weight units.  The scale has a resolution of 0.0001 lb.  It can only weight up to 3.3lbs, but that is fine for what I do.  You can get higher rated scales, but the resolution goes down.  When weighing light things like nylon spacers, you need the resolution.

First you zero the scale with the container you want to use, then you go through a calibration routine.  The scale tells you how many parts to load.  It has a few options for this, but I generally use the 10 piece count.  You then load the 10 pieces in and tell it when you are done.  It then tells you if the scale has enough resolution to do the job with a “PASS” message.

You can then dump parts in and it tells you how many are in the container.  You actually get quite good at estimating hand fulls, so you get quite close with the initial toss.  You then know how many more you need.

Awesome….my new favorite toy!  About $125 on eBay.

I did not give a lot of in depth thought when choosing the MakerSlide extrusion length to purchase.  I did not want a lot of waste, so I just bought the largest piece I could handle.  I figured 6″-12″ average waste on each piece could be expected.  The longer the piece, the less percentage that would be.

The manufacturing size limit was set by the anodizer who could only handle about 20 foot lengths.  The limit on my end was about 15 feet.  This was due to what I could realistically cut.  My space is about 27 feet long, so if I put the saw in the middle I could cut most reasonable sizes with a 15 foot length.

When it came time to cut the material, the reward requests came in all over the map on length.  On past projects I had used some simple logic to fit the pieces into the stock, but that was yielding some serious waste now.  I dreaded the thought of 10-15% waste and little chunks lying all over the shop.  I had heard about cut optimization software and decided to look into it.

It turns out that there is pretty well established math behind this.  There is a good article on Wikipedia about it.  It is generally called the Bin Packing problem.  There are 1D (length, like my problem), 2D (area, like out of a sheet) and 3D (volume, like boxes in a container) problems that can be solved.

I tried a bunch of freeware, shareware and demo software.  I was really impressed with the results.  They did not always yield the same results, but generally agreed within about a percent.  The choice came down to a flexibility and a few key features.  I did not have the time to roll my own solution from free software libraries, but I knew I wanted to do some customizing.  I decided to go with an Excel add on from Optimalon.  The Excel format allowed a lot of quick macros and imports to be easily added.

The software allows you add in a number of stock lengths.  This allows me to put in the standard raw lengths, but also some scraps that might be able to be used.  You enter the cuts by length, quantity and ID.   The ID can be used to determine what customer the part belongs to.

One feature I wanted was a way to label all the parts.

I have several Dymo label printers that I use extensively.  I wanted to automatically print labels from the software.  I found that Dymo had an SDK.  The optimization software prints a cut table for each piece.  I feed this table to an macro that uses the label printer.

This string of labels is now my cut list for each piece of stock.  I print one string per piece of stock.  A single persons parts are usually scattered among several pieces of stock, so this helps sort it out later.

So far the software works great.  The more varied the lengths, the better it does.  My target is in the upper 90′s for yield.  So far I have found it does really well including some 100% utilizations where the last saw cut is less than the kerf of the blade.  Here is a typical final cut piece.

The only drawback is that the cuts are optimized for material usage and not cutting efficiency, so you are often moving the saw stop on every cut.  If I CNC the cutter, this will not be a problem and Excel can drive the cutter.

I have had a project going in the background to create a small, but strong and quiet spindle for small CNC routers. This is my second iteration of the design and I think it is close to what I want.

Frame

I started with an UHMW frame. This frame presses together then uses some hi-lo plastic screws to keep it together. UHMW is very stiff, but cuts well on a simple CNC router. I used a 1/8″ single flute end mill for all cuts. I try to ramp plunges wherever possible to limit the meterial that tries to climb the tool. It can all be cut from a sheet from one side with the exception of the pocket for the motor. This is needed to get enough shaft to come through. This pocket does not need close registration with the other so it is easy to flip it and run that side. The frame is rock solid. It feels like you could drive a car over it.

Spindle

The spindle shank was a key find off eBay. It has a ER11 collet which can handle a little larger then 1/4″ bits and there are plenty of cheap metric and inch collets available. The shank steps down to 8mm. This is great because the step can ride right on the lower bearing and cheap normal and angular contact 8mm bearings are available. I used an angular contact bearing on the bottom, and a normal bearing on the top. The top pulley installs with a spring washer to keep a 8-10 lb pre-load on the bearings to eliminate axial play. The bearings press fit into the end plates. The lower angular contact bearing takes the axial load from hard plunges. The axial bearing I found does not have a good seal on it, so I am a little worried about that. I am looking for a better bearing, but I might make my own seal that would seal to the spandle shaft. I might add a cover for the front and top.

Pulleys

I am currently using MXL belting which is rated for about 20k RPM, but at this diameter and length I think it can go a lot higher. I was planning to use multiple rubber o-rings, but that requires custom pulleys.

Size & Weight

The overall size is rather small at 90mm x 84mm x 82mm and total weight is 0.72 kgs. You mount it by tapping holes into back side. I will have a standard set of holes, but leave room for custom mounts.

Motors

It accepts a variety of motors. You can use univeral motors for small power tools. These will work on AC or DC and are good if you want to run it off 120/220VAC. You can also use RC hobby motors. These are available in brushed and brushless DC. A brushed 12VDC motor is cheap and the you can use a cheap PC power supply. I also test a water cooled brushless DC motor. This is the quietest option, but has the added cost of a speed controller. The motor shown will do over 30k RPM. I need to modify the top to give clearance for the water fittings. It can run for a few minutes before it gets hot, if you don’t load the motor too much. This motor can pull over 550 watts continuously. That is more than 2/3HP. I am hoping a simple PC cooling system will do the cooling.

Speed Control

The speed controller is controlled like a hobby servo. It uses pulses in the range of 1ms to 2ms to set the speed. You can program the controller though the servo interface to determine if you want reverse, etc. I decided to use an Arduino to control the speed. There is a servo library that makes it easy. I have the Arduino reading a pot them setting the speed accordingly. You program the controller by powering it up with the pulse input set to max speed. You then can set a few options like range and direction.

Next Steps

The next step is to find a way to do real world testing with it.  I need a water cooling system and something to mount it to.  The design will be released as open source.

We use a lot of solder stencils where I work (during the day).  We usually buy stainless steel framed stencils for about $300 each.  For prototyping we usually hand paste each pad.  We have an semi-automated dispenser, but it is still tedious work.  I see several places like Pololu selling low cost mylar solder stencils.  I wondered if my Buildlog.net 2.x home made laser cutter could do it.

I researched a few blogs and pulled some information from Pololu.  Pololu sells 3mil and 4mil mylar stencils and recommended 3mil for fine pitch work.  I decided to buy the 3 mil mylar.  I picked it up on my way home from McMaster Carr.  It was a life time supply for about $15.

• http://www.pololu.com/catalog/product/446
• http://hackaday.com/2010/03/19/laser-cutting-solder-stencils/
• http://www.ladyada.net/library/laser/pcbstencils.html

I found a bunch of old small SMT PCBs that I could play with.  I got the top side paste mask  gerber file for it.  I imported the file into a Gerber tool called ViewMate from Pentalogix.  This is a great program that I have be using for years.  A partially disabled version is free.  I have found that it has plenty of useful features.

Most PCB layout software has layers for the solder stencil.  There are industry standards (IPC) for the size of these pads, but they are generally a little smaller than the pad.  Often large pads, like thermal pads under big power ICs are divided into smaller windows or dots.  This prevents excess solder from causing problems.   With this in mind you probably need to shrink the pads even further to deal with the kerf of the laser.

ViewMate has a nice feature that allows you to shrink the apertures.   Apertures are a somewhat archaic term from when artworks were done optically on film.  They basically mean the shapes.  To use this feature select the Setup…D Codes menus.

Select all the shapes in the list and select the Operations…Swell menus.

Enter a negative value to shrink the shapes.

I then printed 1:1 to a PDF.

ViewMate has a lot of export options, but most of them are not available in the free version.  PDF is fine for what I needed to do.  I then imported the PDF into Corel.  I cleaned up a few extra lines and text in Corel and moved it over near the origin.

If you were always going to make your own stencils,  you could probably skip a few of these steps by defining your stencils layers with the right values.  Pololu actually shrinks it differently in X than Y for even better performance.  Many CAD programs could print straight to PDF or other formats then.

Corel is a front end for my DSP laser software, so I was ready to try making the stencil.  The PDF has vector information so you could cut it or engrave it.  Everyone seems to recommend engraving, so I gave that a try.

I was not sure what to put the mylar on.   I decided to hang it in the air.  I taped inside a wooden frame.  I tried different power levels and speeds and looked for my best result.  I onlt tried about 3 settings combinations before I ran out room.  I looked closely and they all looked pretty good.  I think I got the best at 200mm/s and about 60% power.  The power was not too much of an issue.  It seemed better to cut it with more power than it need.  It tended not to heat the surrounding area.  The step over was 0.15mm.  That probably could have been smaller for more accuracy.   There was a slight smoky haze after cutting that I rinsed off with water.

It matched up perfectly with the PCB.

I saw an artical in EDN Magazine today called “So you want to build an H-bot?”. It describes a cool little light duty method to get XY motion. It is used in pick and place type machines. It uses two motors and one open belt. The belt is fixed at both ends to one end of an axis. The rest is run over idlers. By controlling the directions of the motors, you can move in 2D space.  The article does a great job of explaining it.  If you both motors in the same direction one axis moves.  If they move in opposite directions, the other axis moves.

I thought it would be fun to try it in MakerSlide. This is a just a conceptual drawing with most of the parts free floating where they would be attached with brackets or plates. The two plates in the middle would be firmly bolted together.