Quick and clean PCBs for week-end projects

Abstract

I started making my own PCBs at the age of 10, using a pencil on PCB. 10 years later I bought a kit with an UV table, the ferro-chloric acid tank with bubbles and heating, and presensitized copper, but found it very difficult to use for occasional week-end projects and continued to work with the pencil. With SMDs becoming more and more common, pencil is difficult to use for precision work, wasting a lot of time trying to route and adjust PCBs by hand and making marks on the board using needles through paper, which was not great. Over the last 10 years I've been experimenting with various techniques that can significantly shorten the time needed to go from an idea to an actually working board, ideally done the same day for week-end projects. This has now become a reality thanks to two significant improvements: laser engraving and a rocking etching tank. The whole process is described in this article with downloadable schematics and code at the end.

Problems to address and solutions

Over time I've identified multiple problems that needed to be addressed, all of them were causing either long operations or poor quality:

1. designing: I use pen+paper a lot when thinking. I take notes and draw random circuits regularly everywhere on my paper. But I found that it's very hard to get back to an old drawing for a power supply regulator, a serial converter, a MOSFET driver or anything quite simple that will still waste time redoing. Plus sometimes I'd like to share a schematic with friends, so I started to take photos of some of them and to archive them. Not really convenient. Example:
   
2. testing: using breadboards was nice in the early 2000 but with the trend of SMDs they are less usable or at least you don't as easily transport your circuit from the breadboard to a DIL socket on the PCB anymore. And experimenting with analog circuits is not my favorite thing to do. I'm a programmer and only understand logic. For me an analog signal is a signal that takes a long time to transition between 0 and 1 and has potentially exploitable side effects during this time.
3. routing: going from the schematic to the copper traces is a long but relaxing task. Some people play sudoku and others route PCBs. The problem with this is that mistakes are easy to make, and time flies very fast when doing this. It's not uncommon for me to spend 3 hours routing a simple design until it looks usable.
4. transfer: the method I was using to switch from paper to PCB relied in simply redrawing the circuit on the copper using a pencil (over the years I developed a pretty accurate mental representation of 1.27 and 2.54 mm pitch that require fairly little adjustment). And when the circuit was a bit too complex then I used to make dots on the copper by picking the paper using a needle. I would then use these marks as start/end points for certain tracks (typically 16-pin DIL circuits). This can also take a lot of time and the result usually isn't great, especially on the edges where connectors are expected to be placed:
   
   
   
5. uniform etching: when you put your PCB into the etching bath, if you don't heat it, it can take hours (especially in winter when the solution is cold). And if you don't regularly shake it, the result is often a disaster because locations where the copper started to be removed have saturated the solution with copper, which doesn't act anymore on close places. So you end up over-etching some places and under-etching others. Plus the pencil doesn't help, because it tends to make thin tracks (thus lots of copper removal is needed) and if you try to make large areas they are not uniform in thinkness and result in lots of holes at the end of the etching process. Also the areas where you accidentally put fingers sometimes need to be fixed using a cutter.
   
6. drilling: with all the long process above, it's not uncommon to finally have your etched copper clad in your hands at 2am. And when you're in an appartment, starting to drill at 2am is problematic. Also there's often a missing diameter in your drill bits, not to mention the pain it is to break one at the end of a sunday afternoon when shops are closed.
   

Without really thinking about these, I actually addressed all these issues one at a time in reverse order:

• I got used to avoid drilling by using SMD components. It turned out that more and more modern components only exist in this flavor. They are way cheaper, do not require drilling nor cutting pins, and result in smaller circuits at the end, which is not bad. Also I found SMD circuits to be easier to adjust in field. Experimenting with different SMD resistor values and changing them in field 4 times is much easier than with PTH (pass-through hole) ones and you much less damage the board. But this has an impact on testing. Making such circuits on breadboard is possible as long as you have equivalent components. This is not always true for some components like micro-USB connectors, large value capacitors, or integrated circuits and you then have to solder one on a small SOP-to-DIL adapter, meaning you have to de-solder later to finally place the circuit on the final PCB, or have another one.
  
  
• SMDs being less testable and my difficulties with analog stuff made me naturally migrate to microcontrollers. I've used them quite a bit, even the 8048 and 8051 when I was a kit, which had way too many pins to make clean PCBs by hand (DIL40). But nowadays with Atmel's ATTINY series you can have 1 kB of flash and a 9.6 MHz clock in the size of a 555 for almost the same price, and it requires less components around, resulting in something easier to route!
  
  In addition it can be adjusted in field by reprogramming it. That's why I now have a Bus Pirate board with an SOP-8 clamp, to change my mind after the board is finished, and upload program fixes or new EEPROM values.
  
• excess of etching on SMD ICs causes real mess with too thin tracks or missing IC pads, so I really wanted to address this. In 2010, while patiently shaking a bath during etching, I came up with the idea of making a rocking stand that would do the job for me, which is described below.
  
• For the transfer, it remained an issue until a few weeks ago when I received my laser engraver, achieving unprecedented results in accuracy and track density.
  
• however in order to use the laser engraver, it means that I need a digital representation of my PCB and will not perform free-hand drawing anymore. This force me to switch to Eagle CAD. It still is quite a pain for me to use but it finally allows me to archive and share my work, which is not bad, and it allowed me to reach new density levels by removing all the clearance I was used to leave around my components in my free-hand drawings. In the example below, the IC in the middle is not an SOP-8 but a µSOP-8, with a pin pitch of 0.65mm, and as can be seen, there's enough room inside to route up to 4 tracks between the pins!

In the sections below I'll proceed through all these steps to show a workable process for any hobbyist who cannot devote 5 hours on a rainy sunday to try to figure how long to UV-bath a PCB nor to route SMDs by hand.

Designing with Eagle + PCB-GCODE

Interestingly this is the part where I've lost a lot of agility. With pen and paper it can take me 5 minutes to draw an awful circuit that develops the principle I want to realize. But in order to benefit from all the benefits in other steps, you have to give up on pen and paper. In fact not completely.

I'm using Eagle CAD for this, which is now part of Autodesk. Its schematic editor is terribly painful to use. It can literally take 2 hours to draw something very simple if you want to do it right, and you very frequently regret having moved something. You can quickly end up with nests of wires all over the schematic that you don't know how to simplify except by destroying them and drawing them again. You frequently "connect" wires to components which are in fact not connected so your circuit is wrong and needs fixing afterwards, and worse, most of the time is spent looking for your component in the library, especially when these are connectors. Except for the nice RLC library which provides standardized resistors, inductors and capacitors, there's nothing like "standard" connectors of various pitches, you have to go through each vendor's catalogue and often end up picking the wrong one. If you take the wrong one and want to replace it later, you'll lose your connections if the pin names differ. In general there's nothing like "generic SOIC-8 circuit" with pins numbered 1 to 8 nor "generic SOT89 transistor" etc. I sometimes ended up giving up after 20 minutes reviewing many components and picking a random one having the same case, even though it results in the wrong part being displayed on the schematic. But the layout is OK (typically a PNP transistor instead of an RF amplifier).

Some would ask why I absolutely want to have the correct component. The response is simple: because the component you put on the schematic will be the same used on the board, with its final footprint. I was advised to always start a circuit by making my own library. I tried, but a lot of things are counter-intuitive and you end up having to redo the same thing multiple times and not figuring what step you missed. It took me one hour and a half to make a µSOP8 circuit that I needed. That's far too much for just a Sunday afternoon.

I figured that Eagle CAD really is a professional tool. It's not suited at all to occasional hobbyists because its learning curve is steep and if you use it only every 3 months there's no way you'll use it correctly because you'll have forgotten all its hidden magic. Also recently its license changed. You have to be connected to the net to use it! This is non-sense! The places where I do circuits are exclusively places where I'm away from people and noise, and usually without good if at all connectivity. I understand this choice from a business perspective to fight against piracy and constantly send ads to their free users but quite frankly it totally ruined their product for hobbyists. Thus I'm sticking to version 7.7 which is the last free one and have no intent to even purchase a more recent version which will add more constraints.

Why am I still using Eagle CAD after all this rant, some may ask ? For two reasons. First because the board editor is pretty good even if aging in terms of ergonomy. And the second which is it little secret, because it supports extensions called ULP (User Language Programs), one of which is PCB-GCODE (I'm using the currently latest version 3.6.2.4 found here, as the one linked to from the Autodesk site is outdated). Note that version 3.6.2.4 brings support for stencils which are convenient to make solder masks. Maybe one day I'll try to switch to alternatives like Kicad, but I'll first have to make sure that something equivalent to this extension exists first because this is the key to this tool.

Installing PCB-GCODE on Eagle 7.7

Installing PCB-GCODE is much simpler than I expected. There's a great documentation that comes with it (50 pages, really worth reading), covering in details what needs to be done to install it, and some tricks to use Eagle better. It can be scary at first, but all you need to do is in fact to decompress the archive into your eagle home directory, then go to the Eagle's control panel (the small window that remains open with the list of projects), go to the Options menu, click Directories and prepend "$HOME/eagle/pcb-gcode-3.6.2.4:" in front of the current value:

And that's done! Now from the board editor, when you click on the "Run ULP" icon (the one written in yellow over gray):

It opens a dialog inside the pcb-gcode-3.6.2.4 directory, in which you just have to double-click on "pcb-gcode-setup.ulp" to launch it:

Contrary to my initial impression this is not the installation utility but the utility you run to set up your work (step between passes, layers etc:

This is where you can choose which layer(s) to generate the outline for, the minimum clearance you want between any track, the maximum one as well (since adding clearance passes takes time), and the step size, which is the amount of material removed on each pass. We'll see this below. For now all you know is that PCB-GCODE is properly installed and that you can start to use Eagle to draw your schematic.

Creating your circuit

You will spend some time here, so if you want to parallelize your work, have a look at the section on painting the PCB below so that you can launch that operation and let it dry while you're drawing the PCB.

You just have to create a new project, it will open the schematic editor. In this one you add components by picking parts from the libraries (or download other libraries from the net), draw wires between them and your schematic is done. It's very important to systematically move your components around after attaching a wire, to make sure the wire is really attached. It's not because it touches that it is attached. When you move your component around you'll see the wires move with it, confirming the operation. I noticed that sometimes the link was established by moving the component:

Once the circuit is finished, switch to the board editor, place your components, either route manually or using the autorouter (I personally try a combination of both, start with the autorouter then fix what I don't like). It's important to place the components on the correct side, and with SMDs it's easy to get them wrong. While I find more natural to work seeing the top, I'd say this works fine if you exclusively use SMDs. If you mix SMDs and PTH components or just connectors, better keep the top for PTH and the bottom for SMDs (and try to get trained to seeing through the PCB because then all your components are reversed). To switch a part to the other side, just mirror it. Pads appear on both sides from what I've seen. I haven't figured yet the best practice to shrink the board's size once the traces are drawn. Maybe it's better to always keep the same amount of clearance everywhere to get a reference, maybe better align it to the closest track while still respecting DRC rules, I don't know. Typically you'll get this result (note that I did it on the wrong side again, the red one is the top):

Generating the outline for copper tracks

Now's the moment to convert this to the operations needed to turn around the tracks to make some clearance in small steps. We'll call pcb-gcode-setup again and configure it to emit an outline for the relevant side (theorically bottom, but top in this example). Then it's needed to configure the step size and the minimum and maximum amount of clearance around the tracks. This requires a bit of background.

With a laser, the spot is very thin and is not round. It's more like the intersection of two ovoids which are almost rectangular. When one dimension is thin, and bright, the other one is not focused and conversely, so when you adjust the focus to see the smallest spot, you have something between a round and a square, with most of the light concentrated into a small spot. The quick drawing below tries to explain this better.

The most concentrated adjustment above (the middle one) will show the highest power density at its center, still with an effect, albeit smaller, when touching the two ovoids of the axis (axis of the laser diode, unrelated to the engraver's so you don't even choose). So even if to the protected eye it appears like half a millimeter wide dot, in practice the active area is way smaller and will require numerous passes with very small steps in between. Also, the energy spread by the two avoids will definitely affect some tracks' shapes during these passes. This is usually visible around very small round pads which end up not being exactly round and are slightly larger on an axis than the other one depending on the initial beam inclination.

But this is not a problem at all once well understood. In my case I tried with 0.05mm between two passes and that was not enough, sometimes a few very thin remains of copper still appeared (less than 0.05mm wide), as can be seen below. Note that it's barely visible to the naked eye, you need a magnifier or a microscope to detect these anomalies (I'm using my camera which has a resolution of ~0.01mm) :

The integrated circuit pads are roughly 0.35mm wide and the space in between is about 0.3mm. The steps were too large (0.05mm) and the beam was not wide enough to erase 0.05mm of matter at once. Thus I'm using 0.025mm passes and up to 0.6mm clearance, which leads to up to 24 passes! Note that my engraver uses 80 steps per millimeter so in theory it is able to move the beam in 0.0125mm steps (12.5 microns).

In practice after setting the passes to 0.025 or even lower, occasionally a very thin line will remain. It turns out that micro-stepping (the principle of moving a motor of less than one step) isn't always perfectly precise and that some very small areas may sometimes be missed. This completely disappeared after I upgraded my motor drivers for more accurate ones, I'll explain this in another article. But even then, such very thin tracks are harmless and are so thin they can be removed with a soft but sharp blade if needed.

In the second tab ("Machine") it's possible to adjust the feed speed, which is the speed at which the head moves when the laser is on. I used feed speeds of around 380 mm/minute but my engraver was calibrated at only 25% power (max of 1000 while I produced files using a power of 255). I successfully used about 1200 since then but that was after changing the motor drivers, so you need to experiment there. You can start with a low value for a small PCB to get an idea of the time it takes and if it gives a good result in a reasonable time, no need to further optimize.

Once the settings are filled in the boxes, just click on the "Accept and make by board" button. Then the board editor appears again with some automatic processing inside it. The layer is first filled, then cleared around the tracks. It will take a few seconds to a few tens of seconds depending on the number of passes and the board's size. The progress is visible in real time with each pass causing the screen to be updated:

It's worth noting that with too small boards, the software ignores the board's size and takes some margins around. I haven't yet figured exactly what's happening, I've suspected it could be due to the device names which cause some text to artificially expand the work area, as visible above with "TINY13V" stretching the area, but I could be wrong. Once the process is complete, the resulting work is previewed for each side and output:

It's possible to remove the colors (C) zoom (+/-), move (arrows) or quit (Q). Each colored line corresponds to a different pass. Note above that the margin is huge and the reported board size was definitely affected by this centering issue that I suspect to be caused by the text. For now I've dealt with this manually by post-processing the G-CODE output. The files are in the project directory with extension ".tap". G-CODE is pure text so they can be consulted and even modified with any text editor.

Due to the way the tracks were made in incremental steps, it results in numerous laser head moves which tend to take a lot of time. There are many G-CODE optimizers available on the net, some directly running into the browser. These ones are useful in that they'll apply some optimization algorithms which reduce the head's travel time. In practice most of the time they will result in making all passes around a given track (or set of tracks) before going to another track. In my experience it can roughly cut the engraving time in half. That can be 30 minutes of work saved for 30 seconds of optimization so it's worth trying. I've successfully used the one on xyzbots.com though it requires a bit of care because sometimes it doesn't update its contents if it detects an error, and renders the previous one instead.

Preparing a copper clad

Now that we've addressed the design and routing parts of the job, we'll have to work on the transfer from the file to the board. When I was experimenting with various methods several years ago, I had the idea of using a UV laser diode to selectively lit a presensitized copper clad and replace the transfer paper and the laser printer approach that almost always gave me poor results. And while thinking about this, I thought "ah if at least we could have a powerful enough laser to directly burn the protective layer, we'd save so much time and steps, thus reducing the cumulated quality loss. Obviously when I saw this inexpensive laser engraver, I thought it would be a real failure from me not to try this old idea.

I considered a few approaches for the protective layer:

• paint
• solid ink
• tape

I could run some tests on electrical tape and a few other plastic tapes like the thin brown one for use with cardboard boxes. The laser properly destroys the matter there, but the result is dirty and messy because there is still some glue below the burnt tape and when you try to remove it, you tend to make other parts move. Note, I think it is technically feasible this way with a lot of patience, but in my opinion it's not worth it.

I went to a local DIY store to buy a spray of black mate paint. I wanted the blackest possible and really mate so that it would absorb the maximum amount of light and would not require to work at too low a speed. Well, to make a long story short, at this point I have not found anything better. There are multiple benefits in using paint:

• it's easy to store, just keep the spray bottle, it's always ready for use
• it's relatively inexpensive (~8 EUR for ~300mL I seem to remember)
• it's quite fast, they indicate 30mn before touching but in practice when it's hot and dry enough in 5mn it's usable.
• if you're not happy with the result, just clean it up and do it again.
• the paint layer is extremely thin thus the etching precision is not affected too much and the result is ultra-precise:
  
  
• there is a single material in all the depth, contrary to tape which has plastic (or paper) on top and glue at the bottom, so the cleaning is much easier.

So what I did was to clean up my copper clad (dish washing product is really got at removing the oxide layer, the color changes immediately). I scrubbed quite a bit on it with steel wool, then went outside, sprayed the copper with the paint and waited till it appeared completely mate (which is another benefit of the mate paint, it's visible that it's done). The steel wool is an important step. The smoother the surface, the cleaner the result will be because the burnt paint will have no rift or trench to go into.

Since then I found better than going outside, I just place a large piece of paper on the ground and put the clad on it before spraying. This way I can leave it unattended while it dries. You must just be careful not to have too much dust in the air which can deposit on it, nor to walk too close.

Now it's time to place the painted clad under the laser head, adjust the focus so that the dot is barely visible with the glasses, that's when it's the thinnest and has the most absorption by the paint, and send the G-CODE there. I found that if the surface on which the PCB is placed is not perfectly stable or risks to vibrate during the moves, it's sufficient to place some wet absorbing paper or toilet paper under the board to keep it firmly in place.

Engraving the circuit outline

The G-CODE sender I'm using is UGS classic and it works well enough for this job, and shows the progress made, which is appreciable. It requires Java 1.8 but doesn't have any extra dependency. It worked out of the box on my Slackware. What's nice with paint is that you don't destroy any hardware (except the paint itself) during the tests, so you can actually try to send your file there, observe the result, and try again with different parameters if desired, or even try different G-CODE senders.

You will note above that the PCB does not start at the origin and leaves a lot of unused margin, which I really do not want. This is where I'm using my gcode-fixup utility to measure the work area, and apply a compensation offset to X and Y:

$ gcode-fixup laserdot.top.etch.tap | tail -n1
(minx=3.584800 miny=13.376500 minz=0.100000 maxx=26.330500 maxy=25.688700 maxz=0.100000 maxs=0)
$ gcode-fixup -X -3.5848 -Y -13.3765 laserdot.top.etch.tap > top.gcode
$ tail -n1 top.gcode
(minx=0.000000 miny=0.000000 minz=0.100000 maxx=22.745700 maxy=12.312200 maxz=0.100000 maxs=0)

And now by using this file it's properly aligned and starts exactly on the edge, so I can align the laser dot to what I want to be the lowest corner in terms of etching:

Now's time to release test button on the laser module, the put one's protection goggles and to the Send button in the interface and see the work being done.

There is very little smoke on this paint and it smells like acrylic. So it might actually be made of tiny acrylic grains which then burn without residue. The traces appear pretty clearly when lit under a strong light while it is engraving (keep your protection goggles on even if you don't feel that the beam is blinding). After two minutes or so, the work is complete. The paint is burnt around traces for at least as large as configured (typically 0.025 to 0.6mm). The copper may be revealed in some areas when the paint was cleanly vaporized. Let's pass this under tap water to clean the residue. I scrub it with a toothbrush. It's possible to press moderately strongly, the paint is resistant. Pretty quickly all the burnt paint disappears and reveals a pretty precise copper track.

At first this is a bit confusing because you're seeing copper where there won't be any at the end of the process. Just keep thinking that the paint works like the PCB pencil or some transfer paper. Note that the copper is not that clean above because the steel wool I had was very thick and was leaving many scratches. Since then I bought a much finer one which leaves a mirror-like copper clad. Do not put your fingers on the copper yet, it's still sensitive to fat.

Now mission accomplished, we've got a computer assisted schematic transferred very accurately to the copper clad. The rest of the process is well known and more straightforward. Except if we like to have a bit of fantasy...

Uniform etching

Remember the horror stories with stagnant ferro-chloric acid etching different areas at different speeds above ? In 2011 I tried to address this issue by making a rocking stand to place the etching tank, with the PCB in it. For this I reused a servo I had (one with a broken gear exactly in the middle, which I replaced in a robot). I fixed it to a plexiglass plate with rubber pads to prevent slipping and made a circuit to produce oscillating pulse width to make it oscillate left and right. The construction is not particularly solid, just using two screws on one side to rock it and a single screw on the other side to serve as an axis, but it's OK since it never has to take much weight. I've added a mobile LED strip that I directly connect to an external battery to send some light from below and see how the etching progresses, as the epoxy is translucent and thus heavily contrasts with the remaining copper areas. It looked like this (and I still use it for each and every PCB I make):

By then the circuit was tailored around a PIC 12F675 micro-controller which was programmed in assembly. It took quite some time to experiment with various oscillating patterns because each time the program had to be rewritten differently.

The first attempt I made was a naive triangle wave, like the following, consisting in simply doubling the speed compared to the time and inverting the direction at mid-trip. This repeats when reaching a full period:

The problem is that at the edges it was changing direction abruptly and splashing the table around with ferro-chloric acid, leaving yellow stains everywhere. I started to think that I needed to place a spring to slow down the change when reaching the end when I remembered that an oscillating spring follows a sine wave, and that as such, making a sine wave would create a smooth movement:

But this micro-controller did not have anything to compute a sine wave. I thought about placing a table there but it didn't even have enough flash to store both a sine table and the program to use it and send the pulses. Mind you that the processor doesn't even support a multiply and is purely 8-bit so I had to implement all operations in assembly, even just for the amplitude, the speed or to convert the signal to a pulse.

But looking at the curves above, it's worth ignoring the repetition and starting to look closer, particularly at the shape of the part between 0.75 and 1.

Doesn't this curve remind you something ? It looked to me like a parabola. And this didn't surprise me, I had some very old memories of math lessons seeing how trigonometric functions were calculated using polynomial functions with declining ratios as powers were increasing so it made sense that the square was dominant somewhere in the curve. I compared it with the parabola from a normal square function scaled to the same range:

Given that a sine repeats the same form in 4 identical quadrants in different polarities, I just had to build my alternate function by superimposing it over the original sine:

This ends up like this (using floats and a period of 1.0, directly usable in gnuplot):

 frac(x) = x-int(x)

 sq(x) = x*x

 sin2(x) = x>=0.75 ? sq((x-0.75)*4)-1 : x>=0.5 ? sq((0.75-x)*4)-1 : x>=0.25 ? 1-sq((x-0.25)*4) : 1-sq((x-0.25)*4)

Let's zoom on the first period on the two functions now:

I measured no more than 6% error in the worst case in the middle of the curve between the two when using 8-bit integers for my variant. That was perfect for my use case. And since I already had implemented the 8*8bit multiply to handle scaling, I didn't have much more to implement there.

Now given that we don't care about the sine value but only about respecting the repeating pattern, we can shift this by half a period, use a period of 256 steps, and use the most significant bit of the input as a sign bit for the result after the multiply. This has the benefit of resulting in very small code, and looping on the counter overflow. The algorithm is so simple that it was reasonably easy to redesign it for an AVR micro-controller programmed in C:

/* returns ((x*x) >> 7) + 128 using exclusively a 8*8=>16 bit signed
 * multiply. AVR: ~0x18 bytes + call to mulhi3().
 */
uint8_t sq8(signed char x)
{
        x += 128;
        x = ((int16_t)x * x) >> 7;
        return ~x;
}

/* returns sin(angle*pi/128)*128, which is a sine centered around 0. */
int8_t sin8(uint8_t angle)
{
        uint8_t ret = sq8(angle << 1);

        if (angle & 128)
                ret = ~ret;
        return ret + 128;
}

A PCB was made, taking into account the lessons learned from the 12F675 version. First it uses the exact same footprint as the previous board to support replacing it. Second, while the previous version had a jumper to use only the first half of the servo's range to support my servo with a broken gear, I figured it was still not convenient to perfectly center the stand, so instead this jumper was replaced with a 3rd potentiometer to center the stand. The 3 potentiometers are thus:

• center: defines the location of the zero (more exactly the base value added to the pulse width).
• range: defines how far the stand goes in each direction around the defined center.
• speed: defines how fast the stand moves.

With these 3 potentiometers we do not really depend on the internal oscillator's accuracy since anything can be compensated with them. The speed can go from very slow (maybe 10s per period) to something like 10 moves per second so it's supposed to cover about every use cases. I figured it can also be used as a servo tester even if it's not its primary function:

Once connected to the stand and the etching tank it works fine:

And now look below how a circuit being etched bounces back and forth and is uniformly caressed by the acid. The light that comes from blow is emitted by the LED strip visible above. One day I should think about removing that annoying sticker under the tank.

The final circuit looks like below and can be downloaded along with the code and pre-compiled firmwares for ATTINY13 and ATTINY85 on GitHub here.

A previous version was done like this and used to make the next ones, it served as a boot strap in some ways :-)

What I usually do is to put some ferro-chloric acid in the tank, place this in the microwave oven for 20-30 seconds and heat it to about 50-60 degrees C. That's the temperature where I find it the most effective. Then I throw the PCB into it, and in less than 5 minutes it's finished and perfect. Here is what it looks like for the circuit featured above, first just after rinsing it under clear water, then after removing the paint using steel wool:

One benefit of this etching method involving the laser making contours around the traces is that it removes little copper, is fast to etch and does not consume the acid too quickly (I probably only reloaded mine once over the last 5 years). However there is quite a visible problem here: the outer track remains and while it will usually not be a problem it can become one if some connectors have to be placed flat over the board (which is what this circuit will experience). This is extremely rare, but if this happens you have to pull off the outer copper track using a sharp knife.

Adding a solder mask

Why not add a solder mask ? It's really superficial and not a requirement but it can actually protect the tracks from corrosion and give a cleaner finish to the board. I experimented a bit with a sheet that is supposed to be processed using UV light. It's a thin layer of resin between two thin plastic foils. The two methods I've attempted for now are a bit dirty.

In the first cases, I'm using the stencil output from PCB-GCODE. It contains all the SMD components pads. I directly send it using UGS and cut the pieces through the top plastic layer. It's important to know that the blurry side needs to be etched mirrored and the other one has to be etched normally. In order to limit the number of mistakes, I first etch a piece of cardboard and if I'm satisfied, I then switch to the real solder mask.

But I found that, as expected, the stencil is made for the solder paste so it doesn't include pads for some connectors. I will have to see in the PCB-GCODE extension if it's possible to enforce the use of extra layers to force these ones to appear.

Hence the second method, for use when some pads are missing. I tried different approaches, one involving a PDF export and pdf2svg (which gave me very poor results because there were inner and outer paths for each pad). The other one was different, in Eagle I performed an EPS export using the CAM processor, enabling only the tCream and Pads layers. I then imported the EPS file into Inkscape, it respects original dimensions and has the exact same drawing. At this point it is possible to proceed in raster mode using 305-Engineering's extension. At 10 pixels per millimeter the output is reasonably quite clean.

However in both cases it appears that the green foil is extremely reactive to heating, so it's important to only cut a small piece. During the cut you can hear some loud pops. And the raster mode is way more straining for the matter, so I wouldn't exclude to see it catch fire one day. Thus it's important to be careful.

Another point to keep in mind is that the laser's wave length is close to the UV used by the resin to polymerize and harden. So I don't know if it can work fine for large surfaces, maybe some parts will harden while other areas are being cut. This needs a bit more experimentation.

Once cut, just use the toothbrush to remove the burnt parts. Use two pieces of duct tape pressing the plastic in sandwich and placed against each other, and pull them off. The blurry side will be peeled off without damaging the green resin. You then have to place it on top of the PCB and be careful to properly adjust it until all pads are correctly exposed. The green resin is slightly sticky so once pressed it will stay in place. But do not abuse this property, the resin is extremely fragile and will break if pulled more than 3 or 4 times.

The wise reader will note that I forgot to peel off the outer copper track on both circuits above one. For the resin to properly attach to the copper, it needs to be laminated or at least heated and firmly pressed. I don't have a laminator so instead I used a thick copper plate and a heat gun for 1 minute at around 100 degrees.

Note that I forgot this step for the circuit on the left and the difference will be visible.

The resin now needs to be exposed to UV light for 30 minutes approximately before the top plastic layer can in turn be removed. The UV lamps normally used to transfer PCBs are perfect for this. The plastic protection must not be removed yet. I did this mistake for the board on the right:

Beware that the board will be very hot at the end and will slightly stick to the glass. As long as it's only the plastic which sticks it's not dramatic though, but I slightly damaged the other one which didn't have its protection anymore. I haven't found a solution to this yet, but it's not a big deal. After this you can use either some duct tape or a sharp knife to peel off the plastic and reveal the solidified resin. The one which was not heated didn't stick well and lost some parts when doing this. The other one is perfect.

Last step, tinning the exposed areas

Once the board is protected with its solder mask, it's possible to bath it into a "liquid tin" solution (in fact it's a mixture of tin sulfate and I don't know what else to reduce the redox potenial). One minute is more than enough, in fact in a few seconds the exposed pads already become silvery:

I'm personally not convinced by this operation. The few times I did it I found that the solders were more difficult to take than with raw copper. Maybe it protects better over the long term, I don't know. Potentially we'd need a similar solution for gold plating, but it must be quite expensive. I'll probably try this again a few more times and will give up if I see that the results make the soldering operation more difficult.

Conclusion

This process looks long here but it really is not. The longest part is to draw the schematic. I think that I'll end up making my own library of generic devices to save a lot of time.

The solder mask looks great but I don't know if it really brings any benefit. It adds to the time needed to finish the circuit, and also makes it more difficult to debug it if it does not work. However when properly done with effective separation between pads, it avoids accidental solders between very small pins, so it might be worth using if soldering some PLCC48 for example.

It allows to make impressively clean PCBs with components that I never imagined I would one day be able to use (such as µSOP-8 with 0.65mm pitch), and this the same day as the idea happened, which is unprecedented for me.

Links

• Laser Engraver: https://www.banggood.com/2500mW-A3-30x40cm-Desktop-DIY-Violet-Laser-Engraver-Picture-CNC-Printer-Assembling-Kits-p-1003863.html?cur_warehouse=CN
• Eagle CAD: https://www.autodesk.com/products/eagle/free-download 
• PCB-GCODE:  https://groups.io/g/pcbgcode/files/2Software/pcb-gcode-3.6.2.4.zip
• G-Code optimizer: https://xyzbots.com:4000/gcode-optimizer/
• Universal G-Code Sender: https://winder.github.io/ugs_website/
• g-code fixup and manipulation utilities: https://github.com/wtarreau/gcode-fixup
• code and circuit for the rocking stand: https://github.com/wtarreau/rocking-stand
• Bus Pirate board: http://dangerousprototypes.com/docs/Bus_Pirate

My first experiments with the EleksMaker A3 Pro laser engraver

It all started while following some links...

I was having a look at a review for a new single board computer (I don't remember which one) with a link to the Banggood site, and in the suggestions I saw some inexpensive laser modules. Clicking on them by curiosity revealed this appealing laser engraver that made me wonder whether I'd really need it... It turns out that I've been imagining for a very long time that I could possibly make PCBs either by directly printing on presensitized copper boards, or by painting a board in black and then burning the paint. At this price (around 200 EUR then, it went down further since), I didn't risk much so I decided to order it.

Receipt and assembly

I received it in a quite small parcel, the kit is made of lots of small pieces and long, thin bars. There's no ground plate in it so you have to plan putting something to protect your table. The assembly instructions are a bit scarce, they're made of series of photographs with almost no text in EleksMaker's wiki. But actually the photos are well detailed and almost everything is pretty straightforward. My friend Benoit's kids were impatient to see it so I thought it could make a good week-end activity to let them assemble it, thus I waited for the next week-end and verified I had everything available. On the next week-end, they came and I opened a browser on the wiki with the instructions and let them do the work. They're 8 and 11, don't read English, and it took them two hours to assemble everything with no help (actually yes, they asked me to tighten the screws of the controller board as they were afraid to risk to damage it). I was impressed by the result, they even managed to properly tighten the wheels on the bars so that the motors could move smoothly without shaking. It's really nice when you see that such a device can be assemble by kids, it means the instructions are pretty clear and universal!

There were some extra parts at the end, that reminded me a re-assembly of something I'd have disassembled... Initially that worried me a bit and I realized that it was on purpose, in case you break or lose one. Such extra screws and nuts are welcome for later improvements. And as a small plastic box is provided to hold them you don't risk losing them.

The part on the cables assembly is not obvious, it never appears on the photos. We tried different approaches. Leaving all the cables floating around is not convenient because they tend to catch anything around. Passing them all in the provided plastic roll makes too rigid an assembly. I finally figured that passing the Y motors' cables inside the lateral frames and attaching the laser and X motor inside the plastic roll was almost the best solution.

Similarly, the controller board isn't well placed: on some photos it appears vertical, which is the best solution for the cables. But the screws that hold the PCB prevent from centering it and you have to push it much lower, where it prevents the device from touching the table. We placed it horizontally and it used to push the cables below the laser beam, not a good idea either. Finally I moved it vertically again after removing two of the 4 screws that hold the controller board. They're not critical and it still holds well in place this way.

Build quality

I was really impressed by the build quality, especially for the price. I had expected something a bit flexible or shaky but no, it's extremely rigid, everything holds well in place and moves smoothly. There are no tension areas and the axis move perfectly parallel to the frame.

I don't like the cable passing method at all. The one on the sides is far from being perfect, with the cable falling under its weight and occasionally getting stuck between the plastic block and the frame. It doesn't happen often but when it does it ruins what you were doing. And the plastic spiral to hold the X motor and the laser cable together isn't completely smooth due to being rolled around the cables, and tends to occasionally force either against the plastic part of the controller, or against the X motor's fixation. I found that making it arrive by the right of the motor and using the laser's cable to hold it in place is what gives the best results. But it can happen, I'd say in 2-3% of the operations, that you hear your motors "jump" and miss a step because this spiral got trapped somewhere. This really is not anything to worry about at all, everyone will find their own solution to this.

A support is missing, and you have to put something riskless under the engraver. I initially used a glass plate on top of a thermal protection for ovens. Then I made a support using 2 aluminum corners to serve as a support for the glass, thinking it could also serve as a ruler, but it immediately became much more complicated to align stuff on this because we'd lose some degrees of freedom:

Then I thought that some marble could be nice as it would cast the light once the material is cut without risking heating, but finally went for a thin 40cm*40cm concrete slab apparently made for walk paths in gardens. And it was very cheap (4.5 EUR).

A few security rules

If you consider that you'll be careful and will never damage the table under the machine so you don't need a protection, you're wrong. The laser is turned on during resets or certain operations. It can also hang turned on due to a software bug. You definitely want something which can dissipate 2.5 watts of power in a 50th of square millimeter. That's roughly 125000 times the light density that reaches the ground in summer under the mid-day sun (at 1000W/m²). By the way, protection glasses are MANDATORY.

They are mandatory for two reasons. First because you never know if you'll get a reflection. Second because the light point is so small and concentrated that you don't feel blinded by staring at it, but it destroys your eyes. I found that working on the device one evening despite wearing the glasses was straining for my eyes. So you really want to be careful. And take care to work a very bright room, this will further protect you by having your pupil almost closed, compared to being wide open when working at night. The glasses provided by default do not offer a very good protection to be honest, but you can actually watch a piece being made with them if you don't stare too long. Red ones are easily found on the net and protect much better. However they protect so well that you don't see much around and you develop a higher sensitivity (your pupil extends). So in the end I found a better comfort with the green ones. It's possible to stack them on top of each other for an increased protection but then you won't see anything else.

I found that illuminating the piece being etched with a strong concentrated beam of powerful light helps a lot while observing. You even get a clearer image.

And if you're working on something too bright or with reflective parts inside, don't look at the beam, use a camera instead. You can easily replace a dead camera, you cannot easily replace a dead eye.

Very first tests

The difficulty starts right here. Laser engravers, like 3D printers, use a language known as G-Code to describe the moves. I've never used G-Code before, and have zero experience with the required software. The vendor's site suggests to use their EleksCAM software, but I couldn't find it on their site, it looks like you have to create an account on the forums to find the download link, and I'm definitely not going to create one other account on yet-another-site just to download a piece software, which apparently is only for Windows, which I don't have.

Digging on the net quickly drove me to a number of important software parts:
- GRBL G-Code parser and CNC controller, which is the software running inside the controller on the board. It is important to know this because there are some variants betwen language implementations and it's better to make sure other software are compatible. The device is shipped with version 0.9 of the software.
- UGS (Universal G-Code Sender), which is a Java-based application made to send some G-Code to a device over a serial port
- J Tech Photonics' plugin for Inkscape, allowing to convert any vector drawing to G-Code

I also found quite a useful test file called "test_pcb" on this page, producing the test pattern appearing below (I hope it's OK to show the image here):

It brings the benefit of allowing me to first test the hardware and low-level stuff before having everything ready.

I found UGS "classic" to work "well enough". It's a bit heavy and you hear your laptop fan spin when it works, and it spews hundreds of Java backtraces into your terminal while it operates, but it has the merit of being cross-platform and apparently not crashing. Also it gives you access to the G-Code console where you can send directly commands to GRBL, so it's convenient to use to report some settings, move the head or turn the laser off/on.

I found that the "reset zero" operation didn't work, but this was a limitation of my old firmware (0.9) which was later addressed. So I just had to first go to zero position, then move the axis by hand where I wanted. I figured moving the axis by hands is not a good idea because the controllers support a mechanism called micro-stepping, and when you move the motors by hand, you simply "reset" all possible micro-step that the motor might have engaged. Also it's possible to get the left and right motors slightly shifted, thus having the X axis not perfectly parallel to the frame. It's better to use the arrows or X/Y buttons to move the head, then power the laser off, click "goto zero", and power it on again.

Then I wanted to give the J Tech Photonics plugin a try. I downloaded some test SVG images from the net. These are not always easy to find, most links are squatted by vendors who want to charge you for a small image, or by links to this crappy Pinterest site which suddenly sends you a modal pop-up forcing you to either create an account or click "Back". Despite this I easily found various ones including an HAProxy logo, an ant, a ruler, an Eiffel tower Kirigami (to make card board unfold in 3D), and a lot of freely downloadable and well categorized images here at onlinelabels.

Selecting everything and clicking "Extensions/Generate Laser Gcode/J Tech" proposed me a number of options to generate some usable G-Code. I experimented with various speeds, numbers of passes etc. The "travel speed" is the maximum speed at which the axis may move when the laser is off, and "laser speed" is the maximum speed at which the axis may move when the laser is on.

The travel speed depends on the hardware build quality and motors power and precision. Traveling too fast results in imprecise movements. I found that I shouldn't go over 2400mm/min to keep accurate moves. That's 40cm/s so it means one second to go from full left to full right. That's fast enough for almost anything.

I observed that the laser speed heavily depends on the material used : moving too fast doesn't even mark because the material doesn't have the time to heat enough to vaporize or melt. Moving too slow can easily make the material catch fire. In this case it's better to pass faster with a lower power and run multiple passes. I found that speeds around 400mm/min were perfect to cut paper and thin cardboard in a single pass without ever catching fire. Cork and light woods tend to catch fire almost instantly.

The plugin is a bit confusing to use at first because it draws the paths onto your artwork and displays some coordinates on top, that you have to manually select and delete afterwards:

A few times I managed to render the G-Code not for my object but for the previously produced path, so that can be a bit awkward when you don't know but is not a problem once you got used to deleting these.

Sometimes the path doesn't appear just because it's at a totally different location. In this case just press Ctrl-A to select everything an you'll generally see it caught by the selection. Apparently it's how most Inkscape plugins work. It's not necessarily bad but you need to get prepared to this and think about saving first. Another hint is that the plugin will not produce any valid content if you open a file that is not part of a layer, so you need to see a later in the layers dialog. In this case, just select everything (Ctrl-A), copy (Ctrl-C), create a new document (Ctrl-N) and paste at the same position (Ctrl-Alt-V). Also don't use the plugin with multiple Inkscape documents open, or you never know which one will be rendered (it's not necessarily the one you're seeing and I still have to figure how it choses which one it renders). It's particularly troubling when working with multiple versions of the same artwork and you can't seem to observe  the effect of your changes. And since testing G-Code tends to be destructive in that you have to burn some material to compare the results, you generally prefer to stay on the safe side and limit uncertainty.

It's also important to note that Inkscape is still in very active development. My version was 0.92.1, I had too many issues, upgraded it to 0.92.4 and while it's better, it still rarely works more than 5-10 minutes without crashing if I'm not careful. I found so many situations causing it to crash that if I wanted to start to file bug reports I wouldn't even know where to start nor how to describe what I was doing :-( At least it's kind enough to save your work when it crashes. What I figured is that you must never ever undo an operation, you have 50% chances that it crashes (that was my first attempt to get rid of the extra paths lefts by the plugin), and each time you open an bitmap image (png, pdf, ...) you're taking risks as well (I suspect I'll end up being able to describe a reproducer for this one which is extremely frequent, I don't remember having successfully opened more than 2 images in the same session):

There are issues when importing PDFs, where units displayed on the ruler do not match the ones displayed or that use use, and even if you change them, each time you save, they're switched back to "px". I found that selecting and copying the artwork into a new document and saving it as SVG would often fix these issues. The interface is not intuitive at all for a beginner since many disallowed operations simply do not give you any feedback nor hint, so when you fear you did something wrong you press Ctrl-Z and either lose some work, or see it crash. Once you get more used to it you tend to be extremely careful to avoid such operations, you save more often and it crashes less often.

Despite being extremely annoying for these issues, it's still worth making the effort of trying to use it without getting discouraged, because even if it does have a long learning curve, it's powerful and heavily documented on the net (even though most tutorials are painfully long videos instead of just saying "press Ctrl+Shift while doing this or that").

And for PCB ?

[Update: full article covering PCBs from A to Z now posted here]

Then I tried to play with a PCB I made under Eagle. That's where I understood I was going too far. One first needs to understand that Inkscape works with "paths". Objects, pixels or anything are totally irrelevant, what matters is the vectors you're making with your pen on the paper in some sort. When you import an image, you can't do anything useful with it by default. And importing a PDF only makes an object from which you cannot derive a path (other than the rectangle surrounding the image). There are examples on the net explaining how to detect edges on such an image to make a path but these required a menu entry that I didn't have under "Path", which is "Trace Bitmap" (not to be confused with "Trace Pixel Art" which is something different).

I later figured that Inkscape had to be built with "libpotrace" installed to have this, so I ultimately rebuilt it from latest sources after installing this library (both of which went amazingly well by the way). Anyway there's quite some value in rebuilding Inkscape, as bugs are reported and fixed almost every day so by staying up to date you avoid a lot of them).

Thus I attempted to export the bottom layer of my PCB in Eagle as a PDF, then to convert this PDF to SVG using "pdf2svg", then import it into Inkscape, to realize that it had lost all the tracks' width and they were replaced by thin lines! It was not Inkscape's fault as ImageMagick would display the same lines. Then I tried again by exporting the layer as a PNG, using "potrace" to convert it to SVG, open it in Inkscape and convert it to a path. This actually worked pretty well, but I had to figure the scale myself and resize the shape appropriately. I later figured that superposing the unusable PDF version and the SVG that I was resizing would significantly help to provide the scale.

I could produce the G-Code needed to draw the tracks' contours, send it using UGS to the engraver over a mate black-painted PCB, cleaned it under water and watch the result:

There were two defects where some tracks ought to have been straight but one side followed an arc. I suspect it's a combination of the path detection and the plugin because on the screen this issue doesn't exist. At first glance this wouldn't prevent the circuit from working.

One very cool aspect of working with paint is that if you don't like the result, you can clean it and try again. I was fine with this one so I sent it to the ferrochloric acid bath to etch it and test the result.

Now looking back to this I'd say it wasn't terrible, because I did so much better since. But actually I was impressed. At first glance, the cut around the tracks was 0.12-0.13 mm wide. Some copper tracks less than 0.1 mm wide were left intact. I didn't select a specific speed and roughly tried to properly focus the laser. The rounds in the holes were a pain to drill, I had to use a cutter to remove the copper first. And the circuit actually worked! I never had this level of precision before. Just to provide a scale, the 8 rectangular pads in the center are an SOIC8 microcontroller, the pitch is 1.27 mm. And on the left there's a mini-USB connector which is half that, it's 0.635 mm, with around 0.315 mm between two pads. The copper left in the middle between two USB pads is around 0.08 mm and the space is around 0.12 mm. Some issues definitely need to be addressed but the initial goal was already met!

Going further

I tried other G-Code senders, such as bCNC which is very complete and even allows you to edit and fix the G-Code, but relies on multiple views from which you have to navigate a lot. There's also "UGS Platform" which is the next version of UGS. It's supposed to support a feature called "jogging", consisting in pointing to a location on the artwork and move the head there, which is important for centering, for example when making double-side PCBs. But for me the menu entry is always gray and I cannot click it.

I found that all of them (UGS classic, UGS platform and bCNC) would occasionally hang during a complex drawing, leaving the laser on. I think I figured what happens in this case. The software are actually not frozen, I can send a reset to the controller. It is that the byte stream is too fast and they likely fills GRBL's buffer, causing some characters to be lost, and the firmware is then waiting for the end of a command (likely an LF) that never comes. Maybe their flow control is not perfect, or they don't well respect the output status from GRBL. I later found SourceRabbit G-Code Sender which does not suffer from this issue at all. But its visualization window actually never displays anything so you cannot easily control what's being done. Its progress bar is more accurate though.

While trying to work around transfer issues between Eagle and Inkscape to maintain scaling and avoid issues with improperly converted tracks, I finally found an excellent plugin for Eagle, which is called "pcb-gcode". It's seems to be maintained by a small community though it's difficult to find it for downloads, resulting in many copies floating around. I'm using version 3.6.2.4 from here, and a copy of it was moved to github here, sadly as a single import, thus losing all of its history (no updates since then).

This plugin does something I really wanted, which is to make multiple passes with a growing clearance around the tracks. It produces the G-Code output by itself, for each side, and can even make the stencils needed for the solder cream! Now to be clear, this is the proper way to go to make PCBs using Eagle and the EleksMaker laser machine. The results are purely astonishing and there is no need anymore to switch between multiple formats nor fight with conversion issues under Inkscape. Here's just an idea of what can be achieved with this awesome plugin:

To give an idea of scale, the small horizontal lines in the middle go to a small chip using 0.65 mm pitch, and are spaced by 0.3 mm. Since I didn't use much clearance, it managed to leave some unused copper of around 0.05mm between certain tracks! With proper tuning it must be possible to etch tracks as thin as 0.1mm. I didn't know that it was possible at all with this chemical process.

I also discovered by accident that the device by default uses power level values between 0 an 1000, but the plugins were emitting values between 0 and 255 by default. Thus the machine was operating at only 25% of its power, explaining the hissing sound of the PWM output I was hearing during operation. When pushed at full throttle, the beam is even scarier:

I first made a script to convert the values (G-Code is easily editable), but that's not terribly convenient. After upgrading it to a new firmware version I figured it was possible to change the high and low values in the firmware so I changed them to use the 0-255 range and always use it at full scale. I'm not certain it was possible in 0.9 however. Changing the laser power in the various tools to write 1000 instead of 255 was often enough. I haven't made a PCB at full power yet, so I don't know if it's better for the paint or not. Given that some PCBs can take ages due to the multiple clearance passes, it could make sense to etch them faster at higher power. More experiments and reports on this in another article.

Filling areas and writing text

Writing text is also one fun thing to do with a laser engraver. You can write your name on your mailbox using materials that don't fade away under the sun for example. My first attempt was made by cutting letters in duct tape and sticking them onto a plastic plate. This looked great and is still on my mailbox. But I wondered if it was possible to make plain areas instead using patterns fills.

Making a filled shape in Inkscape is not easy. You need to create a pattern made of many lines, extend/replicate it to the size you need, then superpose it with the shape you want to have and play with intersection/difference between the paths to only keep your stock of lines limited to the path of the original object. But this is actually possible. This is what I've used for the tests below (paint on aluminum, then etched using ferrochloric acid):

It's difficult and not very precise, as it's very easy to end up with irregular lines or lines that are not spaced using an integral multiple of the motors' resolution possibly leading to Moiré effect. I started to think that it might be possible to draw following horizontal only lines in "pixel mode", by just modulating the laser while moving. This is actually what 305engineering's Raster 2 Laser plugin does. And it's pretty straightforward to use. It can even adjust the laser's power depending on the luminosity of the pixels to print grayscales. With GRBL firmware in version 0.9, each change of laser power results in a short stop-start sequence causing a small burn. With version 1.1 there is a new "laser mode" which allows the motors not to stop between laser power changes, resulting in a fast and very clean result. This is actually very convenient to print photos, but more or that in another article. Here are a few examples achieved using this plugin:

Funny faces, gradients, Escher drawing, and backs on cardboard or even a toilet paper roll (those having known the Internet in the 90s will surely recognize something which was famous by then). Dense cardboard like is used for food packing is very good at rendering gradients. The lightest ones like toilet paper roll burn on the surface and do not render gradients:

Cat and dog on wood, village on cork, all of them ignite very quickly and are very hard to get gradients :

Symbols on plastic (more on plastic in another article):

Even on crude steak (a proof that you definitely must not put your hand under the beam):

Making wood and acrylic enclosures

One nice purpose I didn't think about and which I've already abused is to make plastic enclosures for various devices. There is an Inkscape extension called "Lasercut Box" which prompts you for a few parameters (dimensions, how much does the laser beam eat, speed and strength) and which produces G-Code that you just have to send to cut acrylic or wood. I initially tried with wood and didn't get good results due to the limited power, even after 12 passes it didn't go through 3 mm plywood. But a new attempt at full power proved it was possible in 6 or so passes (even if the result is not clean). The wood tends to burn under the laser so it's a bit tricky to figure the good speed and power, some experimentation is needed, but it definitely is possible at least:

For plastic, I bought an acrylic transparent red sheet and tried it. The result is marvelous. I can cut 3 mm in one single pass at a very low speed (20mm/min). It's important to perform some tests, like the pattern below I made at various speeds for different squares. I could finally make an enclosure for my NanoPi-Fire3 board!

Conclusion

This machine is really amazing and opens new perspective for working on hard materials, especially for someone not very manual like me. I think I found the tools I needed to exploit it fully (please check the download links in the text above):

• G-Code senders: SourceRabbit for raster (very likely to hang with others), UniversalGcodeSender (UGS) for PCBs and regular use, bCNC for stuff that requires manual adjustments.
• for PCBs, I design them in Eagle 7.7 (the last version supporting to work offline), convert them to G-Code using pcb-gcode from within eagle. Since the plugin gives a preview, it's never needed to switch to another application to control the result.
• for drawing and cutting, I'm using Inkscape using J Tech Photonics' extension which is quite simple to use, supports multiple passes and is really stable.
• for images and text requiring filled areas, I'm using 305engineering's raster2gcode plugin and I'm using my device in laser mode with firmware version 1.1 (more on that later).
• for laser cut tabbed boxes, I'm using the Lasercut Box Inkscape extension and found that it was best to configure the Kerf parameter to 0.15mm when cutting acrylic.

That's all for this review, more articles will come later on more specific subject.