Programming the CRICKIT for Selective Soldering: A Deep Dive PART 4 @Adafruit #manufacturing #CRICKIT

You’re back!

When we last left off, we had prototyped our first CRICKIT board with pretty decent results. Below we discuss the next steps we took in order to begin optimizing our program for production!

Where do we go From Here?

While we were thrilled that the 9mm nozzle performed so well on the headers and barrel jack, we still had a major issue: time. The cycle time of the panel was a sluggish 8.5 min! With so many panels to process we knew we had to find some solutions to improving the speed of the program without sacrificing efficiency.

The first thing we did was raise the “rapid height” of the nozzles. The rapid height refers to the distance below the board the nozzle travels to before moving rapidly to the next soldering site. The default rapid height in our program template was -0.600″; in other words, pretty far below the board. This means that each time the nozzle completes a path it would descend six-hundred thousandths below the board before moving to the next site.

The default position of the rapid height parameter is set low as a precaution. If the rapid height were set too high you can risk colliding with leads. We began by first setting this value to -0.300″. This meant that the nozzle wouldn’t be traveling as far below the board as before. If the nozzle is traversing less space it cuts down on the amount of total program time. This is a terrific way to easily shave off a considerable amount of time without adjusting any of the program’s primary parameters (flux & solder paths, solder heights, process speeds, dwells).

Programming With 2 Nozzles

Employing more nozzles within a program shouldn’t be seen as a panacea. If you aren’t careful your cycle times may in fact become longer and more complicated! Our software only allowed us to solder with one nozzle type at a time. In other words, we had to finish soldering ALL of the 9mm sites before soldering any 6mm sites. When one type is complete the nozzle retracts and the second nozzle is lifted and begins soldering.


When we started programming the CRICKIT, it hadn’t yet been panelized so we could only program with singular boards. When we ran our first panelized board through the machine we noticed one unintended consquence. We had raised the rapid height value on our first pump (the pump with the 9mm nozzle) so high that the solder flowing out of that nozzle was inadvertently filling in plated thru-holes on random boards as it passed underneath the panel on the way to it’s next site.

We could have just lowered the nozzle back down to a safe zone where the solder flow from the lifted nozzle wouldn’t have been able to reach the holes but that would have meant adding back a lot of time to the cycle! So what did we do?

Hacking The System

Our program was getting there but we were filling in plated thru-holes during random X/Y movements. We needed to trim the fat with regard to cycle time as we knew we’d be making thousands of CRICKIT’s, but we also knew that there wasn’t any way within the software to guide those X/Y movements. Then we had a eureka moment!

When the nozzle lifts, the pump turns on and solder begins to flow, but what if there was some way to lift the nozzle without creating that solder wave? Our solution was to artificially lower the RPM of the pump, therefore lowering the height of the solder wave flowing out of the nozzle and apply a compensating value in the “pump speed change” field on EACH OF THE 9MM SOLDER PATHS.

By lowering the pump speed change to the LIFTED nozzle so the flow of solder didn’t exceed the nozzle face AND applying a pump speed change to each 9mm solder path, the nozzle no longer filled in any of the thru-holes!

…mic drop.

Flux & Solder Path Order and Direction

The components on the CRICKIT pcb are in a clock-like arrangement. When we had been mocking up the program we hadn’t paid attention to the order in which we drew our flux and solder paths. This is of key importance because the software accounts for this order and will consequently perform each task in the order drawn. If you neglect to pay attention to the order and the direction of the way in which you drew these paths (either flux or solder) you may be adding length to the program’s cycle time due to wasted X/Y movement.

The plan of attack was then to re-order the paths so they would be performed in a clockwise fashion thereby eliminating motion loss. We also re-oriented the direction of each path to follow this same clockwise arrangement. This methodology proved succesful and we were able to shave additional time off of the program’s cycle.

Process Speeds

Our modus operandi has generally been to perfect one board from a panel first, then “panelize” the program; effectively extending it for the entire “array” (in this case 6 CRICKIT boards). This is where we found out that we were filling in those plated thru-holes and needed to come up with a solution. Once we did this we began to ramp up solder and flux path process speeds.

We’re generally careful in terms of how quickly we increase these values. When we were still in the prototyping stage we were running both nozzles at 10 in/min. We eventually increased the process speed of the 6mm nozzle to 40 in/min. We eventually increased the speed of the 9mm nozzle to 25.5 in/min for the headers and 16 in/min for the barrel jack.

Being as that we were attempting to solder all 3 leads of the barrel jack simultaneously we wanted to provide extra time for those leads to be soaked by heat. Speeding up the solder speed of this path would not have accomplished this. The headers were a similar story in that they both included numerous leads. The only difference being that the leads of the headers were physically smaller than the leads of the barrel jack so we could run them faster than the jack. Keep in mind though that these headers still contained a lot of leads and thus couldn’t be run quite as fast as the terminal blocks for which we were using a 6mm nozzle.

We also knew that 400 in/min was the highest flux path process speed the machine was capable of. That being said, running your fluxing unit at or anywhere near this value may do more harm than good. You must take into account the shape of the paths themselves and the condition of the machine. For us, it also has to do with physical location! Adafruit is situated relatively high above a busy New York City street with a subway running directly underneath it. Sometimes you can actually see the nozzle quiver ever so slightly when there is a train running underneath us. Even if we weren’t located where we are, increasing the flux process speed too high can cause the flux stream to arc instead of shoot at a clean perpendicular angle to the board.

We eventually ramped up our flux process speed from 75 in/min to 135 in/min which allowed us to shave off precious seconds without sacrificing any quality!

We have a drop-jet (DJ) fluxing unit on our machine which allows us to flux very precisely. We ordinarily leave our DJ frequency values at 80 and maintain DJ drop size at 75. Similarly, we don’t EVER change the value of the flux height or the height of its rapid moves. We never change these values because if one does it can become harder and harder to determine the veracity of your flux deposition within your process.

Flux and Solder Dwell

Aside from flux process speed, we have in the past applied dwell to various flux paths in an effort to increase flux deposition. Gauging the amount of flux dwell one needs for a given site can be tricky and I would urge anyone to proceed with caution. A little can go a long way! We also only applied dwell to the barrel jack’s flux paths given the lead length and hole size that we knew we needed to fill.

Solder dwell values are a bit different in that you can really see the difference in how remaining over a site for a longer period and allowing the heat to drench a lead can provide a favorable outcome. That being said one must play around with the amount of dwell you intend to apply. When we first began programming the CRICKIT we had around 1.5 seconds of dwell at the beginning of each solder path on the board!

Our overall strategy was to lower our dwell times incrementally while concurrently increasing our flux and solder process speed values. In this way we figured we could “burn the candle at both ends”.

“Solder Pump on Delay”

There was one more peculiarity of working with two nozzles simultaneously. Each time one nozzle would retract the subsequent pump would take a while to turn on PRIOR to making its rapid move to the next site. As it turns out you can control this! The default setting for the “solder pump on delay” is rather high (around one second). We lowered this value to one-hundred thousandths of a second as a way to increase our time savings!

Final Thoughts & Outcome

Our initial runs of the CRICKIT panel took 8.5 minutes to complete. After we had instituted all of our changes the program had retained it’s efficiency but was now only running at 2 minutes and 38 seconds! In order to refine your program and make the necessary optimizations you have to build a strong base. Sketch freely and imaginatively but always with the knowledge that the products may still need to be re-worked, tested and QA’d before they can ship. Instead of focusing on problems, exploit opportunities along your way to better solutions.

We hope you’ve enjoyed this deep dive into our process as much as we did in writing it. Stay tuned in the future for more selective soldering deep dives!!

deep dive part 1:


deep dive part 2:


deep dive part 3:




Join 7,000+ makers on Adafruit’s Discord channels and be part of the community! http://adafru.it/discord

CircuitPython in 2018 – Python on Microcontrollers is here!

Have an amazing project to share? Join the SHOW-AND-TELL every Wednesday night at 7:30pm ET on Google+ Hangouts.

Join us every Wednesday night at 8pm ET for Ask an Engineer!

Follow Adafruit on Instagram for top secret new products, behinds the scenes and more https://www.instagram.com/adafruit/

Maker Business — American startups are having an increasingly smaller share of the market

Wearables — Switch the advantage

Electronics — Don’t float!

Biohacking — Optimizing the Warm Up

Python for Microcontrollers — CircuitPython 3.0.0 released!

Get the only spam-free daily newsletter about wearables, running a "maker business", electronic tips and more! Subscribe at AdafruitDaily.com !

No Comments

No comments yet.

Sorry, the comment form is closed at this time.