Back in October I finally decided to get a 3D printer. I got a low cost kit, and one of the glaring issues is the power supply. As shipped, there were loose wires between the plug, the switch, and the supply. No bare conductors, but still not awesome. The switch would just flap in the breeze. I saw some similar designs already made online but none of them really satisfied me. I decided to design my own. It took some time before I could successfully print it, but it's finally done, much safer now not to mention easier to use!
I've shared the design files on Thingiverse. The set of hexagon holes were designed partially to save material, but mostly to try to reduce curling. They weren't sufficient, which is why I only now finally got it printed successfully. I had to get my bed leveled very well plus use a brim, to get this successful print in ABS. The PEI print surface was probably also required; it helped at least.
In early November, Seeed Studio contacted in regards to my
PCB fab comparison post from 2015, asking that I also review them. After a
short discussion they agreed to give me a $50 service credit in exchange for a review.
This post is that review, of the Fusion PCB Prototyping Service.
I had two boards fabbed, plus a metal solder paste stencil. Let's get
into the first board. This is for an incomplete project which I won't
describe yet here, instead just covering the quality of the PCB.
They're fully routed, which seems to be common from Chinese fabs.
There's one tiny "nipple" of extra FR4 consistently in one spot. I
assume this is the very end of the tool path which somehow isn't quite
completed. This seems to be common for individually routed boards, as I've
seen this sort of issue from three separate (low-cost) fabs.
The good: there's both plated slots and non-plated holes, and they came out
The bad: a few boards have extra blobs of silkscreen scattered about, see the
left two. In consistent locations, and there's two more boards (not pictured)
with slightly more faint spots but again in the same locations. Those two I
might have missed if it weren't for these very obvious two pointing out the
locations. Several of the boards have scratches, more visible in person than
in the scanned image here. One of them has a bit of solder mask missing
from a spot over one of the traces. There are several blemishes in the solder
mask, most too subtle to notice in the scan but one (on the bottom right
pictured board) is severe. Perhaps one or two of the ten boards arrived without
some form of blemish or scratch.
The ugly: order numbers added to the silkscreen layer. On this board, it's
at the top right of the front layer, near the power connector. It seems they
put a tiny bit of effort into hiding it under a component, but the presence
at all is disappointing. I'd normally check this sort of thing ahead of time, but
I selected Seeed because they approached me, not because of my normal
evaluation process. I only got to it now that I have the boards and I'm taking the time
to write a review. I went looking, and I found as the last entry in
the Seeed Production Code will be printed on empty space of your PCB page.
Certainly could have been more up front with it. I didn't mind when Dirty PCBs
did this, they're transparent about it. A way to hint to them where the printing
would be least obtrusive would be an improvement. (In this case the fat DIP pads
in the middle will be fully covered by a part, and anywhere on the back
would be better than almost anywhere on the front.)
This second board is a revision of my
environmental sensor project. It's mostly the same, but a USB/UART chip
was added along with a few other small tweaks. I'm putting a front and back
copy each of the first revision into the picture, for comparison. They're in
the bottom right, clearly identifiable as the pair with a different color.
The good: Seeed's blue solder mask is actually blue! More of these boards
came out okay: I put four of ten in my defect-free pile, as I was laying the
rest on the scanner bed to show. All the issues I've got to bring up next
are generally minor.
The bad: Still several defects, including scratches on lots of boards. One,
pictured in the mid right, goes across several holes, deep enough to expose copper.
Two of the boards, but one really in particular, had a surface finish issue, the
whole thing being mottled. The silkscreen shows stippling everywhere on this board.
Side-by-side with the rev A board (the bottom-right two) it's nearly unreadable by
comparison. One of the boards has a stray speck of metal (solder, surely)
sitting off in the middle of nowhere. Thank goodness it's not shorting
something. Another has a foreign object in one of the through holes.
The ugly: this board cares about thermal properties, so it has several
internal cutouts to help limit heat transfer. The Seeed boards are all routed
sloppily. Most of the inner holes have at least one corner where the cut goes
a bit too far, creating an extra divot. And still those order numbers in the
silkscreen. Again sort of hidden under a part, at least they tried.
A curiosity: Silkscreen between fine pitch pads. Both rev A and B as well as my old prototype include the exact same TSSOP part (U3), with 0.65mm between
pins (center to center, 0.40 wide). As best I can tell, the silkscreen gerber
specifies one wide empty area across these pins in both revisions. But:
That's the same footprint manufactured thrice by three different fabs. On
the left is the prototype by OSH Park, in the middle rev A by Elecrow, and on
the right rev B by Seeed. It's the same
"Housings_SSOP:TSSOP-8_3x3mm_Pitch0.65mm" default KiCad footprint in all three
cases, with no custom clearance setting. The mask clearance ends up overlapping
into one large rectangle covering each of the four pins on either side. That's
just how OSH and Seeed fabbed it. But Elecrow actually filled in the mask
between these pins anyway. I can't fault Seeed for fabbing the board as
specified. Overall I'm not excited about the idea of the fab changing the
design on my behalf. In this particular case, I like what Elecrow did,
however. Perhaps I'd never have noticed if I wasn't scrutinizing the boards
for this review, as I never had any trouble soldering them, even completely
I've laser cut my own stencils out of plastic before, but they've only
worked okay. For roughly $20, and with a $50 coupon, I decided to order a
metal one to see what that was like. Board two has several surface mount parts,
and I added a QFN part in this revision.
There's not actually a lot to say here. The measurements were listed online
in the order page (28 x 30 cm) but it was a case of ordering sight unseen over
the internet and not truly understanding the size. I ended up cutting it down
to make it practical to use by hand, and then it worked very well.
I have now used it once, and it was a fine experience. Especially including the narrow pitch QFN leads, which worked great the first time. But then, once I was done, I whipped the board under the microscope to check my joints. The soldering was fine, but up close, the silkscreen's quality issues were clearly revealed. Was the inkjet under-extruding? I can see
that it's a bunch of separate dots, which do not connect to form any sort of
line. The upper case letter "I" in "IO" is especially bad, sometimes
one-and-a-half sometimes just one row of dots not quite making a line.
(This is visible in the comparison shot of U3 above, as well.)
The order I made for everything reviewed
above was two PCBs, 10 qty each, and one metal stencil. That's $9.90 x 2 plus
$19.90 which seemed a reasonable $39.70. But that weight/size came
to $84.20 total after shipping (!). If I try again without the stencil I get
$34.89 total. The same no-stencil order comes out $32.84 at Elecrow.
For an order of just board one, Seeed quotes $9.90 for a basic board
(1.6mm FR-4, 2 layer, qty 10, green mask, HASL, 1 oz copper). Great. But
go through checkout and you'll discover that the cheapest shipping is $12.68,
for 10-18 day service (3-5 day costs $19.43). Elecrow charges $11.50 for their
5x10cm service with otherwise identical specs, but they have a shipping option
at only $6.60 (their 2-3 day costs $18.05). If you're patient that's $22.58
from Seeed, or $18.10 from Elecrow, and a wider difference if you're
impatient. And if I were ordering there, I'd have squeezed into 5x5cm and
saved another $2.
Which is another subtler issue. Elecrow puts their size-based pricing right
up front. I've definitely designed to a 5x5 or 5x10 cm envelope before. But
Seeed just has you type in your size and only then tells you the cost. It might
be that this gives you more/better choice for what to do and what it will cost,
but it's very hard to know what your board will cost ahead of time, or to know
how to focus the design phase to optimize cost. Where is the line? Let's
compare some known prices at Elecrow to what Seeed would charge:
A lot of data to say that they're both competitive, always within a few
dollars of each other. When I use Elecrow's size increments. I've got another
practical board in progress, it's 41 x 130 mm and external concerns force this
particular size. At Elecrow I'd need to buy the 5x15 cm service at $23.48 for
five copies. For five copies at this size Seeed charges $16.84, which is a
significant difference (roughly 28%). But since Seeed will only tell me the
final cost of a board after selecting all options, it's hard for me to take
advantage of these possible savings.
For this review I've pulled out another set of two boards I ordered from
Elecrow in late 2015. (A failed (suspended?) project which I won't go into...)
They're of similar sizes to the Seeed boards reviewed here, and when looking
at them with as
critical an eye as I did when I started writing this detailed review, I did find
two small scratches, out of eleven boards. But I did not find any other issues,
most importantly no order numbers added to the silkscreen. The prices are very
similar, and I can predict the price easily ahead of time.
If I don't need more than three and my boards are small, I'll definitely go
for OSH Park. If I've got bigger boards or I want more than three copies
though, Seeed probably won't be my go to in the future.
Here's the probably final prototype of my Remapcro project. I don't think I've mentioned it (here in writing) before, so: long ago I had a Gateway Anykey keyboard. It had an extra row of Function keys down the left, plus a "Record Macro" button in the top right. Tap record, any target key, then any series of keys (and finish by tapping record again) and the macro is recorded. Tap the target key and now it replays the whole series that you typed the first time. It's a small thing, but it can help to iron out tons of small tedious tasks. For example, while I was working on this schematic I had a need to rename a couple dozen items to add a "k" in front of the name. It was several keypresses to do so, but I used the prototype itself to record a macro, then it was just one keypress, and some pointing with the mouse, all done!
Anyway, I'm working on recreating that same functionality with a piece of hardware. This is easy with software, but the extra row of keys from the Anykey is what makes it really useful, somewhere to put the macros. All the keys on my keyboard already do something! In the picture above at the bottom left is an Arduino Pro Micro, which already has the ability to masquerade as a USB keyboard when hooked to the computer. I'm pairing it with a USB Host Shield, top right in the picture, to read USB keyboard input, and pass it to the Arduino. Normally it is passed through unchanged, but when the record macro button is pressed they're also stored, so that they can be replayed. The chip on the bottom right is the flash storage for that.
This is actually the second breadboard prototype. The first was on a full size Arduino Leonardo, with full size USB shield. It was easy to work with, and the hardware was specifically for that prototype. The array of (six) buttons was going to stand in for the extra keyboard keys, but I'd have to do something unusual to access the extra I/O ports on the host shield, which I'm using for the buttons, and I'd like to leave that bit of hardware free for the real thing, so I've skipped that. I did in fact discover several small things (or maybe, one thing and extra things I created in my confusion, trying to find and fix that one thing ...) but now everything else is working here, so I'm confident enough to spend the time and money to put together the final version with real keys and all.
One of the things I got wrong was setting my logic analyzer to too slow a sampling rate. That made so many things look to be completely wrong, and sent me on several wild goose chases. Never again! I hope ... I also broke out the 8-SOIC socket, to hold the flash chip, for the first time. Very nice, to put this surface mount part on a breadboard. I'll have to get more shapes and sizes of those.
A few months ago I made a "tapper box" to share with the local Killer Queen arcade game community. A side effect of the way the game is played means that your ability to tap the button both very quickly and very consistently goes a long way towards your ability to play well. It was great fun and enjoyed by many. This first box was a spur of the moment weekend project. I took a LCD shield and an arduino, grabbed a button from a video game store and threw it in a box from radio shack with a pile of batteries.
At some point after learning about the nationals tournament this year and decided it would be fun to make a few more to give away there. This involved a bit of redesign in order to be something that I could make several of (rather than just the one) and to be sure the parts would be cheaper (as I'd be buying them rather than mostly using extras just lying around).
First I looked at the LCD shield and understood how it worked. There's power on the left, and more power on the right, dedicated to the LED backlight. In between is signals: contrast adjustment, various control lines, and four data lines. With that understood I could build a simple unit based on the LCD only, rather than the larger and more expensive shield I used the first time.
Then I started laying out both the schematic and the parts. The battery is a holder for two AAs, which goes to a switch, which goes to a 5V boost module. This provides power for the Arduino (a Leonardo Pro Micro) and the 1602 LCD. At the bottom of this sketch I began figuring out how to connect everything: the sixteen pins of the LCD across the top (notice the four empty spots in the middle, this LCD can be driven with either four or eight data lines, and we're just using four here) connect to power and the Arduino. Pins 4 through 7 of the Arduino hook to data pins 4 through 7 of the LCD, Arduino 8 to the LCD's RS (register select) pin, and Arduino 9 to the E (enable) pin.
Here's the first one partially built, inserted into a failed (bad spacing) face plate I still had from the original as a test for size. I needed to verify my ideas about exactly how big they would be. Then the only other picture I took, when I had four of the five boxes made. There you can see the letters A, B, C, D, E hand written on the perf boards. That is the order they were made in, and you might notice that I got them neater and more compact by the third try! The cases were 3D printed, the insides were all hot glued in and the case front and back were super glued together.
For those who are interested I've published the source on GitHub.
If you're interested in making one of these for yourself, there's an easy way and a hard way.
First the (mostly) easy way: Start with almost any full size Arduino. You can get the Uno from (e.g.) Sparkfun or a cheap clone from China. Then get an LCD Keypad Shield, again available both from Sparkfun or China. These should plug right together, one atop the other. Hook the Arduino board to your computer and install the Arduino IDE to build and flash the tapper.ino program linked above. Hook any button's two terminals between the Arduino board's GND and 2 pins. Now it's up to you to figure out how to provide power (your computer can do this) and how to hold it all together. If you have access to a laser cutter, you can use face.svg from the source linked above; it's designed to fit into Radio Shack's 6x4x2 inch enclosure.
Next the hard way. Get an Arduino Leonardo Pro Micro and a 1602 LCD module. Hook them together like my crudely drawn schematic above. Power can be added in several ways, I used a 2xAA battery holder into a 5V boost module, with a switch between the battery and booster. Assemble it all onto something like the perf board pictured. The same button and case concerns apply as for the easy way.
I recently became interested in an RFID-based project. In actuality, revamping an existing project incorporating RFID reader(s). In truth, the application wants five separate cards in five separate (nearby) locations to be readable at roughly the same time. Today they're using what appears to be a RDM630 module, with some electronics to switch in five separate antennas, and this is slow. (Power down, switch in an antenna, power up, wait long enough to be sure the card would answer if it was there, power down, switch in the next antenna, repeat x5.) It would be very nice if it was more responsive.
The thing is that the RDM630 is a "no name" brand product, with documentation scattered and spotty at best. What they've got in common is a set of three headers. On the main five pin header: two of the pins are power, one is unused, and the other two are consistently labeled as the TX/RX pair for a UART. A two pin header goes to the antenna, and a third is both the power and signal line to drive an LED indicator.
These RDM630 modules all speak 9600 baud UART, and for my application the problem is that they all simply output the ID of the card exactly once, when it appears in range. I can't control that timing, so I'd need to be prepared to read from five separate readers all at once. It's not easy to have five UART inputs all working in parallel with independent timing. But there's an RX pin labeled in addition to the TX pin, might it be possible to put these things into a mode where they could be queried on demand, with timing I can control?
These modules appear to be an implementation of a common design for low frequency RFID readers floating around the internet: a microcontroller, an op amp, and some glue. There's no reason that the microcontroller couldn't be programmed with further abilities. But I can't find any word anywhere about what they are, if they exist.
There's also a related module with the same footprint called the RDM6300, with at least two variants. One of them has an extra four-pin header compared to the otherwise common pinout, in the top middle in the picture just above. I managed to convince myself, by pictures available online, that I knew this was the debugging port for the microcontroller. In these variants it was always a Silicon Labs F330, an 8051 variant. So I got one of these RDM6300 modules, and found a cheap SiLabs USB Debug Adapter from eBay. My goal was to dump the code and discover more about how it works, especially if there is an existing way to ask it to behave differently over UART.
Before I continue, for posterity the pins are (from left to right starting at the square one in the picture above): 1 GND, 2 Vdd, 3 C2CK, 4 C2D, which are the power and debug pins for the SiLabs C0851F330 microcontroller (see page 37). All of the pins besides GND lead to vias, but they're trivial to trace through the other side of the board to the vias that pop back to this side of the board where the microcontroller is. It's got pin one on bottom left, and the bottom right three are the three pins in question (besides GND). Note that it's a 3.3 volt part, the regulator is right next to it which drops the 5V "normal input"; this part is also 5V tolerant on all its pins.
I have dumped the flash, and disassembled it. The disassembly seems imperfect, especially all the addresses in the middle of instructions. But there is clearly:
X0db1: mov sbuf,r7 ; 0db1 8f 99 ..
X0db3: jnb ti,X0db3 ; 0db3 30 99 fd 0.}
clr ti ; 0db6 c2 99 B.
ret ; 0db8 22 "
Exactly one place that the sbuf register is referenced, and it seems pretty clear to be a "write the byte in R7 to the serial buffer (memory mapped) "register", loop until the transmit bit is set, clear it, return" routine, which makes total sense for a UART transmission. There is no corresponding read from sbuf, so the default firmware will not, for example, respond with the ID when queried over the UART. This write-to-UART routine appears to be called (lcall X0db1) in three places, all within 20 instructions from each other.
In theory perhaps I could patch the firmware to put such functionality in at this point, but there are challenges. First would be writing such code, in assembler. I could probably write it in C, compile that, and get the assembler that way. Then I'd have to insert it into the current firmware somehow which is even more difficult. Where is the main loop? How do I insert it without breaking existing functionality? And how do I fit it? The dump I've got is 7,681 bytes of a theoretical 7,678 maximum, and the clearly empty bit at the end starts at 7,603, leaving only a tiny bit of space.
In the mean time I've found the MFRC522. It operates on a different kind of RFID tag, but already supports the sort of slave mode "speak only when spoken to" protocol that makes it easy to interface with several at the same time, so I'm continuing by working in that direction.
I've been continuing to set up my new 3D printer, after first assembling it last weekend. This is the first object that I could call successful. After lots of time spent in calibration for the height I went back and checked the diagonal arms which were indeed not all the same length and fixed that last night. Today I tried a couple prints which completely failed to stick to the build plate. A layer of blue painters' tape completely fixed that! This particular test object seemed to stop extruding partially through the top layer, but it's close enough, so I'm calling it my first success!
Besides modding my phone yesterday morning, the vast majority of the day yesterday and today has been spent on assembling my new 3D printer. I've been down on 3D printing overall for some time, largely due to quality issues and the amount of time that it takes to complete a print. I've got access to a 3D printer at work, which has satisfied me for occasional small projects over time. But I just completed a big one. And more importantly, for this post, I also got lucky and snagged roughly 40 one kilogram rolls of free ABS filament recently. For free.
That was enough to push me over the edge and get my own. Forty kg is effectively a lifetime supply. The big project I mentioned took over twelve hours to squirt well under half of a kilogram of filament into my custom shape. I could make 160 of those with this much filament.
Anyway, above is a set of pictures showing all the parts. I got a kit, because not only are kits cheaper, I enjoy putting them together. Plus, it means I know for sure how it all goes together, which helps inform knowing how it works, which makes repairs down the line easier. I've just now completed the last major part of assembly. All the screws are screwed in, all the wires are plugged in. I've turned it on and done the most basic of things (move a bit, go to auto home), and those basic things work.
Here it is in all its glory. You might notice that this is not a traditional ("cartesian") 3D printer. Instead it's a "delta" style, which moves three arms up and down; when moved properly in concert the print head they connect to in the middle can be made to move left/right, forward/back, and up/down. But all the motors doing this are fixed, at the base, driving the arms through belts. So there's less mass to move around, which is always a good thing. Specifically this is a Geeetech G2s Pro. Which in addition to being a delta, which I like, also has two extruders. Meaning in theory (if I can learn how...) it can print with two different filaments, like two different colors, at once. Which presents exciting opportunities.
There's still a ton of things to check. All the wires are plugged in, but are they plugged in correctly? To the right thing? Does it get hot when I ask? Does it squirt out plastic when I ask? Is it level and square in each of the several ways that it needs to be? Are the fans pointing in the right direction? Do any of the wires or tubes bind up when the print head moves around?
So this is not "project done". But it's a significant milestone.
A while ago I decided that I'd wait until near the end of the year and seriously consider opening up my Nexus 5X. First, to replace the nearly year old battery and second to modify it for wireless charging. I completed that work today. This first picture shows the phone opened up. The iFixit guide for battery replacement was very useful. With the right tools, as pictured (except the #000 phillips driver), it was quite straightforward to get inside. It's worth noting that the metallic sticker, still in place as pictured, on the inside of the back cover must be removed, so the electric field can get inside to the coil!
Here's a close up image of the completed modification. I used the +5V point on a capacitor as pointed out on YouTube, but for ground just used the nice big USB-C connector shield, which I verified was also grounded. Some thin gauge wire-wrapping wire is small enough to not get in the way of anything. Since the wires are only around an inch long, I'm not concerned about the resistance of thin wires.
My new boards arrived and I've assembled the first (totally working!) "wi_ther" environmental sensor. The prototype, which I've posted about before, and was supposed to be the final version, is on the left while the new board is on the right.
The new board is larger, to put more space between the hot WiFi/controller chip and the three sensors, which are closer to the proper USB connector, rather than the on-PCB fingers. I got the connector a tiny bit wrong, I had to cut off a bit of the board to make it fit properly, since I put too much empty space around the holes for it to mount to.
You can see three internal cut out slots to help break any thermal transfer from the controller to the part of the board where the sensors are. The surface mount temperature sensor also has extra cutouts around it, and the two other sensors have big slots cut out beneath them, which is nearly invisible in this picture.
I'm still finalizing how I want the software to work. For now this system is running an HTTP server, which can be polled. I've also considered letting it run as an HTTP client, periodically pushing the data out. It might be nicest for it to run as an independent system, keeping a buffer of historical data in memory, in case anything causes my normal system to miss then that data can be retrieved thanks to the independent storage. But for now, it's time to stress test it and verify whether my thermal design for this version helps the sensors provide accurate data. (Early signs are good! In the few minutes it's taken me to type up this post, the reading has remained flat, so they haven't been heated by the processor!)