Soldering surface-mount components

 

The image shows a breakout board for an NCP1402-based boost converter which steps-up 1.5v to 5v; these circuits are widely-used to power 5v (or nowadays 3.3v) from a single coin cell. (The board is my design, in KiCad, based on the manufacturer's recommended application.)

Of more interest here is the regulator component itself. This is the small 5-pin chip midway up the right-hand side of the board. It is a surface-mount SOT23-5 part, approximately 3mm by 1.5mm, far smaller than a grain of rice. Building this breakout board was more an exercise in seeing if it was possible to hand-solder these parts than anything else, since they are widely available for cheap on t'Internet.

So how did I do it? The first step was choosing a hand-soldered footprint for the part in KiCad. Then, once the boards had arrived, this part obviously had to be soldered on first:

• Apply solder to the pad under one of the further-apart pins (on the left in the picture)
• Place the chip over this pad with a tweezers and hold it in place
• Melt the solder on the pad until it flows over the pin
• Solder the other pin on the left-hand side
• Solder the three pins on the right-hand side together. 
• With a desoldering pump (braid should work too), remove the excess solder from these three pins, so they are no longer shorted together.

Tweezers and magnifying glass (or low-power microscope) are essential, unless you are some sort of assembly robot. Fine-gauge solder and a fine-tipped soldering are helpful too.

Note that the circuit itself helped me "get away" with the final two steps of the procedure above: of the three pins on that side of the regulator, one is NC and the other two are connected to Vout. However checking with a continuity tester indicated that they were no longer shorted together, so the pump had worked as expected.

So the experiment being successful, the next step is to build more surface-mount parts into my designs. 10k resistors and 100n capacitors crop up very often so they would be obvious targets for replacement. Stay tuned!

ArduTouch

One of the very few downsides of ordering PCBs from Seeed Studio's Fusion service is the shipping cost. While an individual PCB can cost less than $0.50 in multiples of 10, shipping to Western Europe can add another $20.

One way to amortize these costs is to add more PCBs to an order, either from my own "design pipeline" or by searching online for cool projects. One very cool project discovered in this way, was ArduTouch from Cornfield Electronics.

One the hardware side, this is basically a battery-powered Arduino Uno with an LM386 amplifier driving a 4-Ohm mini-speaker, or your HiFi via line-in. The keypad is very nicely integrated into the PCB, see my construction below.

ArduTouch with Batteries and Cheap Speaker

Software-wise its GitHub provides five (at the last count!) different synthesizer sketches and a library for constructing your own. As usual, sketches are compiled in the Arduino IDE and uploaded by FTDI cable. A nice touch is that they uploaded a BOM for Mouser, making ordering the parts a snip!

I have several PCBs left over from this order. If you want one, contact me through the Tip Jar on the right. However I would encourage you to support the guys who made this great project possible by buying one of their kits.

WifiWeatherGuy

My title will no doubt remind regular readers of 2013's Weather Guy, a weather app which completely maxed out an ATMega328. Well it's had a technology refresh replacing Ethernet with Wifi, XML with JSON and AVR with ESP. A surprising amount of display code survived the upgrade and can be found on GitHub (along with Eagle files and Gerbers).

WifiWeatherGuy

The hardware has also been simplified and now comprises merely:

• A Wemos Mini D1, ESP-8266 development board with USB
• An ILI9163-based TFT display
• A push switch
• A PCB from Seeed Studio's Fusion service

The Wemos has been mounted on the underside of the board as can be seen above, because I soldered its pin headers on the wrong side; however this suggests to rotate the display by 180 degrees, making the build more compact.

The software is built on the following fine components:

• An Adafruit-compatible ILI9163 driver library
• The Arduino JSON parsing library
• The ESP-8266 Arduino core
• The Arduino ESP8266 filesystem uploader

Perhaps the most interesting aspect of this build is its configuration:

• Stored in JSON format in the onboard flash filesystem
• An index.html is served to a browser which loads the configuration file and initialises form input items (via Transparency)
• Submission of the configuration form transmits the form values in JSON format to the server where it is stored back in the filesystem
• The index page also supports firmware upgrade

This pattern, where the client assembles a UI for the user out of pieces obtained from the server is finally becoming prevalent in the wider web, but nowhere is it more useful than here where the client has maybe 200x the power of the serving microcontroller.

The Weather Underground API provides current conditions, a 5-day forecast and astronomical information. Two of these can be seen below.

Sunrise and Moon Phase

Current Weather Conditions

A Tinier Tiny

Now even tinier!

The photo shows an upgrade to last year's tiny ATtiny development board: now even smaller and with fewer components but with better breadboard performance!

The schematic and board layout (for Eagle) along with gerbers can be found here. The pcb (from Seeed, 1€) was cut down to size with a Dremel.

The Next Level

The PCB and TinySensor assembled!

A mere three weeks after submitting the order, Seeed Studio returned my PCBs! The picture above shows one before assembly and the other after. The assembled one is mounted on half of a sick-of-beige case, also from Seeed Studio. This was needed because the PCB chosen was 0.8mm thick and flexes easily. (Perhaps a thicker PCB wouldn't have this problem.)

Assembling a PCB is much easier than stripboard mainly because of the smaller number of holes on offer for each part. Printing the component names helps too but not having them wouldn't have mattered so much, for this project anyway. The main thing to remember is to add the parts in increasing order of height.

The board worked first time! No embarrassing green wires needed! I attribute this to the fantastic job done by Eagle's autorouter. The only change I would make in retrospect is to ensure the capacitors were the right physical size: the parts chosen from Eagle's library had a smaller footprint than the ones eventually used. The Eagle files are here.

Quick-and-dirty graphs of humidity and light from the bathroom over the past 8 hours. (Note the spike at 9am when I was showering!)

Here's the bill-of-materials. Say €20 including headers, nuts-and-bolts, AAA battery, etc.

Part	Qty	€
ATtiny84	1	3.00
14-pin DIL	1	0.15
PCB	1	4.50
Sick-of-Beige Case	0.5	1.00
DHT22	1	3.50
NRF24L01+	1	1.00
NCP1402 3v3	1	5.00
100nF	3	0.05
10k	2	0.05
4k7	1	0.02
Total		18.27

Taking it to the Next Level

TinySensor Board Layout

Up till now we've just used Eagle to draw schematics and, in all honesty, it's not the world's greatest drawing tool. It only really comes into its own when used as it was intended, to assist the complete design process.

What follows is a summary of my experience using Eagle to lay out the TinySensor circuit, described previously, on a sub-credit-card-sized board and generate the files required to fabricate the board. (It's based on a reading of these two useful posts.)

So, once a circuit has been designed and prototyped on breadboard/stripboard, its schematic drawn and checked for errors (using the ERC tool in Eagle), board layout can begin. Unsurprisingly this involves Eagle's "Switch to Board" menu item. A new window appears with a jumble of interconnected footprints corresponding to the components chosen in the schematic view.

The board view is connected to the schematic so that any changes to the latter are reflected in the former. The first changes might be to replace some components by equivalents with different footprints, for instance (and Eagle provides a tool for just this purpose).

However the main action of this view is layout, routing and manufacture. Layout must be done manually, by dragging individual components out of the jumble and into the white rectangle, representing the board itself. At this stage, I chose the board above (it's from Dangerous Prototypes) and deleted the white rectangle. A good rule of thumb is to place the largest parts first, although you'll probably have a good idea of the desired relative positions of the parts, having prototyped it already on stripboard.

It's good practise to try manually routing the circuit, if only to be even more amazed at what a good job the autorouter does. The undo command is your friend here: I found it useful to try autorouting slightly different placements, undoing autorouting before moving components around.

Once satisfied with the placement, print the layout on paper! This provides an essential sanity check of component footprints: use a pin for the drill holes and attempt to fit your chosen parts. Better to discover they don't fit at this stage than when the boards come back from the fabricator!

The next step is to run a Design Rules' Check. This often requires a rules' file tailored to the fabrication process itself, in this case Seeed Studio's Fusion PCB Service. Download the rules' file, load it from the DRC dialog and run the check. This thread contains descriptions of some errors found at this point.

Finally, run the CAM Processor to generate the design files for manufacturing. (For Seeed Studio, this requires its own Gerber Generator, downloadable from the second step of the Fusion PCB workflow.)
At the CAM Processor dialog, load this file from File > Open > Job... and then hit Process Job. This will generate a bunch of files, of which Seeed requires 8:

% zip seeed.zip sensors.{GTL,GBL,GTS,GBS,GTO,GBO,TXT,GML}

A sanity-check widely recommended at this stage is to load up the layer-files above using a separate tool (e.g., gerbv) to see if there is a discrepancy between it and Eagle and correct it. Once this is done, upload the zip file, pay your money and wait!