It all started back in 2015. I was stuck in my tiny dorm room working on my master’s thesis for a weeks-long stretch, and it was driving me a bit insane. So I did what any reasonable person would have done, and signed up for a week-long full-time woodworking intensive.

The class project - a coffee table. Doesn’t look like much, but it’s all hand-cut mortise and tenon joints. Have not done a M&T joint since…

That planted the bug and I wanted my own space to work in. Not an easy task living in central London.

History

Workshop Iteration 1 - Kitchen

In my first 1-bedroom flat, my open plan kitchen/living room doubled as my workshop, with the beautiful stone kitchen island as my workbench. Since I didn’t want to coat the inside of my whole flat with saw dust, I was limited to just hand tools, and spent almost as much time cleaning up as actually building things. Not ideal, but that’s the space I had, and I did what I could with it - simple stuff out of construction timber.

Kitchen for food wood preparation.

Never got around to building a bed by the time I moved out.

Workshop Iteration 2 - Spare Bedroom

In my second flat I had a spare bedroom that I converted into an office and a workshop. Not ideal to have computers in the same room as dusty wood workshop, but again, that’s the space I had. I also had a garden that I could do the very dusty stuff in, and it was at this point that I became the proud owner of a mitre saw, and stopped the character-building practice of sawing everything with a tenon saw. The obligatory first project was the workbench.

Workbench

Not a lot of space, but being able to use a mitre saw outside made cross cuts much less painful, and I was able to build a few more things.

New Workshop!

This year we finally moved into a house with a reasonably-sized garden. As is common practice in the 50s in the UK (1950s, just in case you are reading this after the 2050s), the garage is behind the house, with a narrow driveway for access shared with a neighbour. Cars nowadays are much wider than they were back then, so it is no longer usable as a garage. But that’s a perfect new home for my workshop!

Old garage.

Only a few small issues:

• It’s made out of prefab concrete blocks with tiny windows, so it’s quite dark
• The mitre saw trips the circuit breaker
• The concrete base has cracked and moved significantly over the years
• Oh, and it’s got an asbestos roof

So we got it demolished and hired someone to pour a new reinforced concrete slab.

Bye!

New reinforced concrete base.

When it comes to actually getting a new building in, there are quite a few choices - primarily brick/blocks, prefab SIP (structural insulated panels), timber framing, and log cabins.

Brick made out of sand and lime is the traditional option. Durable, but labour-intensive and has a tendency of developing cracks over time. Concrete blocks is the more modern option that is cheaper, stronger, but less durable.

SIPs are another modern option that is very clever - two chipboards sandwiching some insulation foam, and glued together with construction adhesive. They can be cut to size at the factory and sold as kits. They provide very good thermal insulation, but sometimes humidity problems (due to the very good sealing), and they are quite expensive. They are also not inherently waterproof on the outside, and require a waterproof cladding to be installed, which is often also expensive.

Timber framing is a method very popular in North America, where construction timber is used to create a skeleton of the building, with plasterboard (drywall for North Americans) on either side, and cladding/rendering on the outside for protection from the environment. Relatively cheap, but also quite labour intensive.

Another interesting option is “log cabin” kits, where the company supply wooden tongue-and-groove planks that simply slot together to form the walls. Cheapest option, but the building will grow and shrink over the seasons, and thermal insulation is also not great.

In the end I decided to go with a log cabin option as I quite like the idea of having a wood workshop be made out of wood itself, and be easy to modify using tools in the workshop. The wood movement requires some care to work around (especially for wiring), but since we are going to be woodworkers, that’s something we need to be very familiar with anyways. Here is the delivered kit:

The kit as delivered.

They are available in all sorts of dimensions from multiple suppliers here in the UK, and we decided to go with a 15m² kit because that’s the largest size that doesn’t require planning permission in England (this is not legal advice - the actual rules are a bit more complicated than that). We also chose a pent roof design because we want to put solar panels on top of it.

The build process itself is fairly straight forward with two people. Most of the build happened over a weekend, though we did need a bit more time to finish it up. The instructions say it should take two people two days… I guess that’s possible if it’s your 5th build! If you are planning on building one I would recommend budgeting more time than that. Reading the instruction front to back to understand the whole process first is very helpful, as well as arranging the bits so that they are stacked in reverse order of when they are needed. That makes the build process much more pleasant as you won’t have to be digging for every piece.

Otherwise it’s really just hard labour lifting every piece and hammering them in. Some pieces will be a bit warped (to be expected as it’s a natural material) and require some creativity and cursing to install, but otherwise it’s really just like IKEA assembly. For the really warped pieces we wetted them a bit and clamped them overnight with some straight pieces. Old woodworking trick.

First an elevated base to allow airflow underneath.

Building up the walls.

Slotting the window and door frames in.

The only slightly tricky bit is the roof, and only because we had to climb on it.

Nailing the roof boards.

Slightly precarious.

Insulation boards.

We then needed some kind of roof covering. Felt is the standard option, and the cabin company could have supplied that, but we ended up going with a EPDM rubber roof that’s more durable and also easier to seal against, which is important because we are also doing a DIY solar panel install, and that require putting quite a few holes through the roof. Unfortunately we didn’t glue it down very evenly, so water pools a bit on the low side. Oops! Hopefully that doesn’t cause a problem.

Rubber roof.

The last thing to go in is the floor insulation (suspended with clips to allow airflow underneath) and the floor boards. We used a nail gun here to speed things up and to save our arms from further punishment after having to hammer all the roof boards in. Roof boards need longer and stronger nails because they need to stop the roof flying off in strong wind - floor boards are only nailed (with expansion gaps) to stop them moving around too much, so brad nails with the nail gun are good enough for the floor, but not the roof.

Floor insulation + boards.

All done!

Inside.

Outside.

We treated all the exposed surfaces inside and outside over the next few days, and it was ready for electrics. The old garage was supplied from the main house consumer unit with a 16A supply, which was plenty for the garage, but not quite enough for what we had planned for this new workshop. Fortunately, they had the foresight to use 6mm² armoured cable for the run (much bigger cable than they needed), so we were able to change the upstream circuit breaker to 40A, which allows us to have 32A circuits inside the workshop. Why do we need a 40A upstream supply to have 32A circuits, instead of 32A + 32A? Using the same size breakers would theoretically work, but we would lose discrimination. What that means is when that circuit is overloaded, it’s not guaranteed which circuit breaker will trip first, and best practice is to be able to guarantee that the downstream one will trip. With 40A/32A we don’t have full discrimination since those breakers have sensitivity ranges that overlap, but it’s better than using identically rated breakers. In this case since there is no safety consideration, only conveniece (if the upstream trips first, it will kill all circuits in the workshop, and we have to go into the house to reset it), full discrimination is not a regulatory requirement.

In the UK you can do a surprising amount of electrical work yourself without certification (but you still need to be competent and do the work to BS7671 standards). Unfortunately a new consumer unit isn’t one of them, so this is one for the pros. When hiring an electrician to wire up a log cabin it’s very important to stress to them the necessity to allow for wood movement, otherwise terrible things will happen when seasons change.

We decided to go with a design based on round conduits. No glue is used to bond the conduits to the back boxes or the corner bend pieces, so they are free to slide in and out, and the expansion gaps are all hidden.

What’s with all the extra stuff? That’s my DIY solar + battery system for the whole house, but that’s another story for another day!

Overall we are quite happy with how it all turned out - a bit more work than the companies would have you believe, but really not too bad with a bit of DIY skills, and it’s actually a lot of fun to build!

Next - workshop layout and the solar + energy storage system.

At the end of last year Fede Heinz, a colleague of mine at Google reached out for a collaboration on his Blinkenlights project, to build a web-connected LED matrix driver for his team of about 500 people. It took about 4 months, but the hardware design part of the project has finally come to an end, and in this post I will talk about the hardware design, and how we made all the important design decisions, as well as all the problems we ran into (some of them pretty funny in hindsight). The goal is to give everyone an LED matrix with the controller board, so they can send 16×16 images to each other. We went through quite a few brainstorming rounds and design iterations, but in the end decided to build an ESP32-based driver board, powered by a computer through USB-C, and drives an external matrix. This project is open source hardware and software, and you can find the hardware design on my GitHub repo, and the firmware/software on Fede’s.

BlinkenLights!

Blinkenlights PCB

The PCBs for this project were manufactured and assembled by JLCPCB.

High Level Design

Internal vs external matrix

Once we decided on making a custom PCB, we thought it would be cool to have the matrix built-in to the board. JLCPCB has the WS2812 in their catalogue, and it would only be slightly more expensive than buying the matrices separately. Our first prototype included the matrix. Unfortunately the defect rate was unacceptably high – we had 256 LEDs per board, and a defect rate of about 1% of the LEDs, which means we had no totally working boards!

We don’t really have the equipment (an x-ray machine) to figure out why, but as the WS2812 is extremely moisture sensitive at MSL (moisture sensitivity level) 5a, that’s our best guess. This has caused problems for a lot of people. If we were going for higher quantity it may have made sense to work with the assembly house a bit to try to solve this, but at 500 it doesn’t really make sense, so we decided to use an external matrix instead. We talked to them about this and they took it off their parts library to investigate, but couldn’t guarantee anything.

Rev 1 – with integrated matrix

USB-C Data + Power

We need the board to connect to a laptop for data, and the original plan was to include a USB-C connector for that, but have a separate barrel jack for power (you can see this setup in the Rev 1 board above).

But we had a pleasant surprise – as it turned out, all modern laptops with Type C ports can actually supply 1.5A or 3A, and since that’s enough for our use case, we get to save the cost and logistics trouble of providing a separate power supply, all while helping to reduce e-waste.

Note: taking that much power from USB-C ports safely and in a standard-compliant way requires care. I have written a post on that topic. Please do not just draw that current without checking.

We are also only supporting laptops with native Type C ports, using C-C cables. This makes our life easier because we don’t need to support the whole pre-C mess with the Battery Charging Specification. We can do this because we are only distributing these boards within Google, so we know (almost) everyone has a recent laptop with Type-C ports. If this was going to be more widely distributed, it would probably be a good idea to support BCS, and maybe with another Type-C port that can use a Type-C supply for power.

Microcontroller Choice

We wanted something a bit more beefy than an AVR, but we also want Arduino compatibility because we will be encouraging users (who are mostly programmers but not electronics engineers or firmware engineers) to hack it, and being Arduino-compatible makes it much easier.

The ESP32 is an obvious choice – it’s cheap, fast, and has good Arduino support. We don’t actually have plans for WiFi or Bluetooth, and it was still the most cost effective option regardless. Our boards end up costing just over US$4 each manufactured and assembled, so the cost of the ESP32-WROOM-32 module is actually responsible for just under half of the entire cost of the board ($2.0061 from JLCPCB, at 500 qty).

Would be cool to have a microcontroller with built-in USB support so we don’t need a separate chip, but all the ones with built-in USB I have used cost much more than $2, so would not be cost-effective even taking into account the elimination of the USB-UART chip.

Schematics

Full schematics: PDF

The schematics design is pretty straight forward on the microcontroller side, with the ESP32 module, a CH340B USB-Serial adapter, the standard 2-BJT reset circuit to allow automatic reset from Arduino (more accurately esptool). The reset circuit has slightly different capacitance value from the official recommendations from Espressif, because I found that with the official values it doesn’t reset reliably on Windows sometimes.

Power, USB-serial, auto-reset

See this post for more information on the USB-C part.

I am not a big fan of the CH340 series because the documentation is very sparse, and it doesn’t have a SUSPEND output, which is realistically required to support USB suspend. However, it is available in SOIC package, whereas my preferred chip, the CP2102, is only available in QFN. We used the CP2102 in our first revision prototype, but found that we had a soldering defect rate of about 10%, which is approximately what I have found with my past projects using the same chip. It’s fine for a personal project where I can fix them manually when needed, but we don’t want to have to fix 50 boards in a 500 boards run! If we were building more, it may make sense to try to tweak the footprint a bit to see if we can improve assembly defect rate, but we didn’t want to delay this project. So we switched to the CH340B instead. Those chips are in every low cost ESP32 board and USB-Serial adapters these days.

I quite like the AZ1117 family of regulators for ESP32, because they are rated for 1A, and come in tiny packages (SOT-89 in this case). Here is a nice comparison of standard SMT package sizes. At this package size it can’t handle 1A continuously, but we only need the 1A for current spikes. ESP32 requires up to about 800mA with WiFi and Bluetooth on, but those are always very short spikes, and on average usually it only needs about 100mA. A 1A regulator in a small package is perfect for this kind of applications.

The other significant part is the LED matrix interface:

LED interface

Here we need a level shifter, because the WS2812B uses 5V signalling, and the ESP32 has 3.3V IO. But in addition to that, we also need to power-gate the matrix because it draws about 250mA idle, which exceeds the 100mA maximum we can legally draw from USB without negotiation (and without CC current advertisement / BCS detection). So we have an AP2172A chip that we use to switch on power to the LED once we know we can draw that current.

The AP2172A actually serves another very important purpose – we need a large capacitance on the LED side for voltage stability, but USB only allows a maximum of 10uF on Vbus. If we connect a 470uF capacitor to Vbus directly, there is a good chance that the host will go into an over-current reset while the capacitor is charging up. We did in fact see this in an earlier prototype without that chip.

With the AP2172A, it will limit the charging current to 1.5A per channel (it has 2 channels that we wire up in parallel), so we can have any amount of capacitance on the LED side. We control the chip using the LED_ON0 and LED_ON1 signals. Why two signals? Because we can get either 1.5A or 3.0A available from the host, and if we only have 1.5A available, we can’t charge at 3.0A. Once we have the capacitors charged, we always turn on both channels to reduce the channel resistance, and apply current limit in firmware instead.

The level shifter is a TI SN74LV1T08, with an AND gate built-in. Why AND gate? Because most chips really don’t like an input voltage higher than supply voltage. This can lead to the input pin powering the whole chip through the ESD protection diodes (which wouldn’t have been rated for this), or latch-up. With the signal ANDed with LED_ON0, we ensure that the data pin can never be driven high when the LED power is not on. I like to apply this kind of protections in hardware in addition to firmware just in case, especially since we will be encouraging users to experiment with the firmware.

And then we have config strap pins. They are basically input pins connected to a pull-down, with an open solder jumper to Vcc. This allows the user to set some semi-permanent config options that we can support in firmware. They are like DIP switches, but free and take up less board space! (though slightly harder to use)

We also have the extra pins we aren’t using exposed on a header, as well as 3 capacitive touch buttons (for user experimentation). Remember to always put ground and Vcc on expansion headers!

Straps and expansion headers

PCB Design

We decided to go for a 2 layers design in this case, because it’s slightly cheaper. At 500 qty we would be paying $0.21/ea for 2 layers, and $0.38/ea for 4 layers. It’s not a lot, and that’s why I have not designed a 2 layer board for my personal projects in a very long time, but for 500 boards it does add up, and 4 layer boards would also restrict us to green soldermask with JLC assembly service. This is a relatively simple board, and easily doable on 2 layers, so we went with that. It does mean we cannot have impedance-controlled traces for USB, but since we are only going for Full Speed, it’s not an issue. At 20ns minimum edge rate for Full Speed, transmission line effects only become significant at ~60cm.

PCB layout

We have a rectangular layout with the LED connector in a screw terminal on top, USB-C connector on the bottom, and the ESP32 antenna on the right with a cut-out. The capacitive touch buttons are on the left side to allow them to be exposed if we have a case covering up the rest of the circuit.

U2 is the CH340B that takes up a lot of space due to the huge SOIC footprint. The CP2102 would be much smaller, but that doesn’t help if we can’t get it soldered reliably!

We are using an aluminium solid polymer capacitor for bulk decoupling of the LED matrix. It’s about $0.03c more than a standard aluminium wet electrolytic capacitor, but it’s smaller and higher performance (probably doesn’t actually matter for this application). We actually used ceramic (MLCC) capacitors in an earlier prototype to keep the board height lower (see picture at the beginning of the post), but unfortunately ran into acoustic noise issues at high power settings due to the MLCC dielectric being piezoelectric. The other option to keep the board profile low is with a tantalum capacitor, but I avoid using them when possible because tantalum is a conflict resource. A few manufacturers say their tantalum is conflict-free, but I’ve never really looked into that, and have never really needed to use tantalum. Tantalum is also much more expensive, and have a very exciting failure mode (with an explosion). Be very careful with those!

Panelisation for Manufacturing

PCB fabs generally don’t want to deal with hundreds of tiny PCBs, and would rather deal with fewer larger ones instead. For example, JLCPCB has a limit of 50 PCBs for assembly, so since we want more than that, we need to put our PCBs in larger grids called panels. This is what our panel looks like:

5×2 PCB panel

Different fabs have different preferred panelisation techniques, and JLC requires tabs and mousebites for assembly, which is what we have here. The boards are connected by those little tabs lined with drilled holes, so they can be manufactured and assembled as panels, and we can just break them apart by hand once we receive them. There are rails on the top and bottom – they give the panel some extra rigidity during assembly, and also serve as a place to put order numbers, fiducial marks (marks on the PCB for pick-and-place camera calibration), tooling holes, etc. Those are usually added by the PCB fab, and not something engineers need to care about. Just leave some room for them to do their job. JLC’s panelisation specs and recommendations are here. My panels were generated using yaqwsx’s KiKit tool, and you can see my config here. It has been successfully manufactured by JLC and seems to work well.

Cost

Altogether, the cost is $140 for a 2 panels assembled prototype (20 boards, $7/board).

That comes down to $462 for 10 panels (100 boards, $4.62/board), and finally $2103 for 50 panels (500 boards, $4.20/board).

Cost breakdown

Most of that is ~$1800 for components. That’s about $3.60 component cost for each PCB, most of which is the ESP32 module at $2, the CH340B USB serial chip at $0.60, and the AP2172 USB power switch at $0.35. It’s amazing that everything else (regulator, a bunch of capacitors/resistors, some transistors, a level shifter, and a few LEDs) only add up to $0.65.

Testing

A few days later, our prototype panel arrived! (this is the version with MLCC capacitors that like to sing)

Prototype panel

The panel breaks up easily by hand and pliers, so it’s time to do some testing.

Functionally they all flashed fine, which is encouraging (we had problems due to CP2102 soldering defects before). After verifying that all the boards work with my laptop, it’s time to break out the scope.

I don’t usually do such extensive testing on my personal projects, but since this is going to a lot of people, it’s important that we are well within spec since something that is marginal may just happen to work on my laptop, but not others’, and we can’t realistically test it on everyone’s laptops. USB is the interface between our users’ laptops (which we can’t control), and our boards (which we can), so that’s the focus of our testing. We really want to be standard-compliant here, because that means if the laptops are also standard-compliant (and they should be), we will have a working combination.

Also, I am of the opinion that if we put a USB port on our board, we should make sure it’s compliant. I’m less strict about it if it’s just a prototype and I’ll be the only person using it, but if we are selling or giving away devices to others, I try very hard to stick to the spec.

This is the USB-C probing setup using two USB-C breakout boards (with the pulldown resistors removed), and my cheap DIY current probe board.

Some cool scope shots, with the board plugged into my MacBook Pro. First we have the plug-in

Yellow: Vbus, Blue: CC, Green: Ibus

We see that we draw up to 500mA in the first 50 microseconds or so to charge the regulator input capacitance, but at Vbus = ~1V, the regulator turns on and the second pulse starts to charge the capacitances after the regulator, with a nice ramp up and down. We are down to almost 0 current at approximately 200us, once all the capacitances have been charged.

We also see that CC is ~1V, which means the MacBook is advertising 1.5A available.

Then we zoom out a bit to see the entire sequence to power-on of the LEDs.

Yellow: Vbus, Blue: CC, Green: Ibus

We see that as the ESP32 boots up (around -3.5div, which is about 50ms after plug-in), current draw increases but is still much lower than the 100mA limit. At -2div, the MacBook changes current advertisement to 3A, and simultaneously sends a Power Delivery message. If we have a more sophisticated controller we can try to decode that message and negotiate using PD instead of the much more crude CC current advertisement mechanism, but we don’t, so we ignore it and just wait for it to stabilise (this is allowed by the standard – devices that don’t understand PD must wait a minimum of 10ms after CC voltage changes to make sure they are not confused by PD messages). Finally, at about -1.2div, our firmware confirms the 3A available change, and turns on the USB power switch to charge the big capacitor, which is the current spike at -1.2div. Once the capacitor is charged, we get back down to about 300mA idle current for the LED matrix. Finally, at +0.1div, we turn the matrix on to all white for testing, drawing 3A. This part looks all good, so let’s zoom in to that capacitor charging spike.

Yellow: Vbus, Blue: CC, Green: Ibus

Here we see that we are not exceeding the 1.5A current limit (we designed the firmware to always charge at 1.5A, even though we actually have 3A available in this case). We see that the AP2172A chip is doing its job with a ~500us soft start, and then limiting the charge current to 1.5A, giving us the plateau waveform.

Note that the soft start limits our current slew rate to 3.49kA/s (between the 2 cursor points on the screen). USB spec actually has something to say about that as well – there is a limit of 150mA/us (150kA/s) on current slew rate, so if we limit our current draw to 1.5A, but jump right up to that faster than 150kA/s, we would still not be complaint. Using a USB power switch makes complying with this part of the spec much easier.

Now let’s look at when the LEDs are suddenly turned on to max power (this is the worst case).

Yellow: Vbus, Blue: CC, Green: Ibus

We see that the current is limited to 3A (we have a safety margin in our actual firmware – I removed it for testing), and the current slew rate is at 18.7kA/s. If the current slew rate is too high here, we could have compensated for it by increasing the size of the big capacitor, but we are well within the limit here.

Everything looks good on the USB side! I didn’t try to verify actual USB data because that’s handled by the CH340B chip, and I assume it’s compliant since it’s used in many commercial products, and there’s really nothing we can do if it isn’t.

The next thing to look at is the LED data stream. First a zoomed in view of the pulse shape.

LED data pulses

The voltage levels look fine, and the edges also look fine. They are a bit overdamped with the 470 ohms series resistor, and that’s why the edges are a bit rounded. But 88.6ns fall and 61.6ns rise is still plenty fast enough for this signal speed, and much better than being under-damped, since ringing can read as additional edges. This also allows the user to use longer wires, where the higher inductance would require more damping.

Some pulse statistics when zoomed out:

Signal statistics

Here we see that the short pulses are 250ns, long pulses 874ns, which are well within spec (220ns – 380ns, and 580ns – 1000ns respectively).

This concludes the scope tests, and just for fun, I also took a picture with my IR camera. This is useful to spot if anything is getting unexpectedly hot.

IR image

The 3.3V regulator and the USB power switches get hot, and that’s as expected. The USB power switch only gets up to 54C, which is acceptable. The chip is fine at this temperature, and 54C is actually also lower than the 60C maximum recommended temperature for exposed heated surfaces in ASTM C1055 (“Standard Guide for Heated System Surface Conditions that Produce Contact Burn Injuries”), so in terms of contact burn risk, this is safe as a consumer product even without an enclosure to stop the user poking the hot bits… at least if the ambient temperature is no higher than about 28C, which would put the chip at 60C.

This concludes our testing! We will be doing the mini-production run soon.

Lessons Learned

This is my first ever project to be produced at this kind of quantity, and it has been very interesting experience learning about all the different considerations that go into designing for manufacturability (and design for availability, given the current chip shortage). It’s not difficult, but there are just so many things to think about even for a relatively simple design like this. First we had soldering defects that I would normally not worry about too much but is unacceptable to fix manually at quantity, then we had random basic chips going out of stock between each prototype iteration, chips failing (probably) due to moisture handling, capacitors becoming piezoelectric buzzers, and then there’s the much more extensive testing required to gain confidence that the design will work with a wide range of hardware that we cannot exhaustively test. All very different from personal hobbyist projects where I only need to make sure they work for me, and can do a lot more trial and error, as well as manual hacking to fix things. I knew all those things in theory before, but it’s very different putting them all into practice.

And then of course there is a whole another level out there, designing products that will be produced in the thousands or millions, and require going through certification. As a hobbyist engineer, I will probably never get to work on a product like that, but hopefully I’ll get to do another >100pc design at some point!

I am also in awe how (relatively) easy and affordable getting our boards made and assembled is. With JLC’s assembly service they supply all the parts from LCSC, so although it does mean you have to design using the parts they have, they do have a pretty extensive library, and if your design works with just their components, it’s about as turnkey as assembly services get. You don’t have to worry about sourcing and shipping parts to them, or have them source your parts and potentially end up with “substitutes” that don’t actually work in your design, or counterfeit parts, as you would with other assembly services. To be fair, we did run into some assembly quality problems that required designing around (the LEDs and the CP2102 chip), but still, I’ve always imagined getting boards assembled would be much more work than this as a hobbyist.

Disclosure: JLC sponsored some of my projects.

My first USB-C design!

Disclosure: JLCPCB sponsors some of my projects, but I would never recommend something that I wouldn’t otherwise. Their SMT Assembly service I believe is unique in the industry, and is great for hobbyists who need high quality assembled prototypes for cheap, without having to deal with logistics of component supply.

TLDR: Scroll to the “Putting It All Together” section. Implement that circuit, and use it like a good old Type B port.

Introduction and History

USB is really a miracle connector. I have been designing PCBs for about a decade now (mostly as a hobbyist due to selling out and joining the software world for my career after my EE degree), and of the dozens of boards I’ve designed, I can probably count on one hand all the designs without a USB port.

Why do I put a USB port on virtually all my boards? Because it:

• Supplies power at a convenient voltage.
• Most of the microcontrollers I use nowadays have either a serial bootloader (ESP32) or built-in USB DFU bootloader (STM32), so it can be used to program the chip.
• A serial port for debugging (either through a USB-UART chip or enumerating as a CDC-ACM virtual serial port in firmware for STM32).

What more can you ask from an ubiquitous connector that takes up minimal board space, and uses cables you can buy from even grocery stores? If you want to power your project with a wall wart, USB chargers are readily available, too (even from grocery stores).

But wait, it gets even better. Back in 2014, the USB-C standard was finalised, and Google was the first major manufacturer to adopt it with the 2015 Chromebook Pixel, with Apple following shortly after with the 2015 MacBook. Initial adoption was a bit slow, but over the past few years, USB-C has taken over the consumer electronics market, and most laptops and smartphones come with USB-C nowadays. That’s a very good thing, because USB-B had many pain points –

• USB was not designed to supply significant amount of power initially – only 5V @ 500mA. As a result, to support battery charging, manufacturers started adding proprietary extensions for higher current (and sometimes voltage) – Qualcomm’s Quick Charge, Sony had their own thing, Apple had their own thing, and Samsung had their own thing. None of them were inter-operable, making designing a “universal” power sink very challenging. Eventually USB-IF (the governing body of USB) came up with the Battery Charging Specification (BCS), but it was a bit too late, and it’s also unnecessarily complicated due to having to make do with the existing data pins. It must not break existing devices that don’t understand BCS, and in designs where we need both high current and data transfer, having to multiplex BCS detection circuitry with data lines is always a pain. It’s also limited to only 5V@1.5A, because A-B cables don’t have any identification mechanism, and burning down a user’s house trying to push 5A through a cable designed for 1.5A is frowned upon.
• Different connectors for USB 1.1/2.0 and 3.0.
• Different connectors for host vs device. The initial design calls for USB-A ports on hosts, USB-B ports on devices, with a few size variations for both (mini and micro – they are electrically identical to full fat versions… more or less). It made sense – if all hosts have Type A ports, all devices have Type B ports, and we only make A-B cables, everything works as long as they fit! … Well, until we realised that we want some things to be devices some of the time, and hosts some of the time – phones and tablets. They need to be device when charging or plugged into a computer, but host when we want them to read a USB flash drive or use a USB keyboard to write a long blog post. So like BCS, we bolted it on with the USB OTG abomination, which also left a lot to be desired.
• USB superposition.

USB Superposition

USB-C solved all those problems from the ground up:

• We can now get up to 5V@3A with a very simple detection mechanism that just requires 2 ADC pins, or 1 if we add a bit of additional hardware. No complicated multiplexing needed because they are not on data pins. If we want higher voltage/current, we can get up to 20V@5A with the new Type C Power Delivery standard though that is more complicated. Best of all, this is all standardised. Nothing is proprietary, and all USB-C devices support these (ok, maybe that’s optimistic… let’s just say all devices from reputable manufacturers do).
• One connector rules them all – USB 1.1/2.0, 3.0/3.1/3.2, 4.0, even DP, HDMI, audio, and a few other things.
• One cable rules them all – C to C is all we need (ok that’s a lie, we actually have two types of cables, one basic type for up to USB 2.0 @ 3A, and a fancier type that self-identifies their capabilities). Roles are determined electrically, not using connectors.
• No more superposition!!

Despite being a big fan of Type C from the early days, I have only just designed my first PCB with USB-C, in 2021, feeling like a hypocrite this whole time buying only USB-C devices, and still making micro-B ones!

Why? Mostly because Type-C connectors tend to be much harder to solder (much more pins, about the same total connector size). The standard is also much more complicated, though as we will see shortly, actual implementation is VERY simple if we just want to use it to replace micro-B in USB 2.0 devices (as opposed to hosts).

What changed? Well, JLCPCB started offering Type C connectors with their SMT assembly service, so I have no excuse now!

I did a lot of reading up on Type C for my first project, both official and unofficial sources, and I thought I would write a post summarising all I have learned and de-mystify it a bit, and hopefully encourage other hobbyists/makers to adopt USB-C.

Scope

Type C is a very big standard. The “bible” – Universal Serial Bus Type-C Cable and Connector Specification, is 373 pages long. They clearly learned from their mistake before, and decided to include EVERYTHING that anyone can conceivably need into the standard. But for basic applications, you don’t actually need to know all those things. You should (if I do my job) be able to use Type-C as a micro-B replacement in a standard-compliant way by just reading this post.

I’ll limit the discussion in this post to designing Type-C pure devices (called upstream-facing port or UFP in the spec), pure power sinks (USB-C actually allows devices to negotiate switching power supply direction without switching data host/device!), and communicate at up to USB 2.0 HighSpeed. This I think encompasses most hobbyist applications.

Let’s get started.

Connectors

This is the connector pinout from Wikipedia:

USB-C Connector Pinout (By Chindi.ap, CC BY-SA 4.0, Wikipedia)

It looks quite daunting, but we actually don’t care about most of those pins for our application:

• TXn+, TXn-, RXn+, RXn- pins are for USB 3 SuperSpeed, so we can ignore them.
• SBU1/2 pins are for side band use (used for low speed communication when the port is used for something like DP or HDMI), so we can also ignore them.

That leaves us with these pins –

Simplified USB-C Connector Pinout

Much more manageable. Most of them are pins we already know and love – VBUS, D+, D-, GND. Except they are all doubled/quadrupled now to support reversible insertion. They can (and should) all be shorted together.

The only new pins are CC1 and CC2 (channel configuration), and they do a few things:

• Pull down resistors on the device side tells the host that a connection has been made with a device, and VBUS should be turned on. Unlike Type A, in Type C VBUS is never energised until a host knows a device is there, because the user may plug two hosts into each other, and terrible things would happen if they are permanently live.
• On the device side, one of them will read as ground, and the other some higher voltage. This tells us the cable orientation. It’s important for 3.0/SuperSpeed operations, but we don’t actually care about orientation for 2.0, since we are shorting all the other pins together! I will refer to the non-ground one as CC from now on, though it can be physically on either CC1 or CC2 depending on orientation (and we must account for both possibilities, otherwise our device will only work with cable inserted one way). No, we cannot short them.
• The CC voltage is used to determine how much current is available from the upstream port, and whether there is a connection. This voltage is determined by a voltage divider between host and device.
• If we want to do Power Delivery (we need more than 5V@3A), the communication also happens on the CC pin, but it’s much more involved and we probably want to use a PD sink controller to handle that for us (eg. ST STUSB4500).

The standard requires that CC1 and CC2 be pulled down to ground on the device side with a 5.1k ±10% Ω resistor each (Table 4-25 in the spec), and with a basic C-C cable, only one will be connected to the host, which will have different valued pull-up resistors to indicate how much current it can supply – 56kΩ, 22kΩ, or 10kΩ to 5V, or an equivalent current source, or equivalent pull-ups to 3.3V (Table 4-24).

So in the end, the whole circuit looks like this:

Connectors + cables circuit (Silicon Labs)

In a basic USB 2.0 3A cable, Ra doesn’t exist, but fancy cables that support higher speeds or higher currents will have them to power electronics in the cable so they can tell the host their capabilities. On the device side we don’t care about that, but that’s the reason why we can’t short the CC pins and just use one resistor. Raspberry Pi Foundation did that with early revisions of the Raspberry Pi 4, and it didn’t end well for them. Don’t be like them.

In terms of determining how much current you can draw, just read the CC voltage (remember that it’s the higher of CC1 and CC2). Thresholds are as follows:

Table 4-36: Current advertisement

So what that means is:

• [0V – 0.2V]: No connection (we only care about this if the device is self-powered, because in a bus-powered device, the fact that we have power and the firmware is running means there is a connection)
• [0.2V – 0.66V]: Standard USB current available (the host either has no high current capability, or we are connected to a legacy host with a A-C cable – see “How Much Current Can I Draw?” for more details)
• [0.66V – 1.23V]: 1.5A available
• [1.23V+]: 3.0A available

In practice, most laptops will supply 1.5A or 3.0A, most wall warts will supply 3.0A, and phones (if we use them as host) will support standard USB. The CC voltage may change over time and should be continually monitored. When it changes, the device has 60ms to be compliant with the new advertised current limit (tSinkAdj, Table 4-29).

If we are using a USB-A power supply with an A-C cable, it will always show vRd-USB because the pull-ups are actually inside the cable, since a USB-A host knows nothing about CC signals, and a compliant A-C cable can’t assume the host can supply more. There ARE non-compliant cables that do advertise high current support to device without checking with host. They are a fire risk and should never be used. Fortunately they are less common now in 2021. So if we want to draw more current from a legacy power supply, we have to go back to the pre-Type-C madness on data lines.

Putting It All Together (aka TLDR)

With that, we arrive at the schematics for using a Type C port as a micro-B replacement –

Simple Type C schematic

Vbus, D+, D-, and Gnd are used just like in legacy connectors.

CC1 and CC2 must have a 5.1kΩ pull-down each. If you want to take advantage of the new Type C current advertisement mechanism, they should be routed to ADC pins on your microcontroller, but if you don’t need that, leaving them alone with just the pull-downs is perfectly fine, too, and it will act just like a standard Type B port electrically.

Note that I am using a connector with only the USB 2.0 pins. If you are using a fully-featured connector, all other pins can be left unconnected.

Choosing a Connector

Now that we have decided to add USB-C to our project, we need to pick a connector to use. It’s not easy – there is a huge variety on the market, and some are much harder to use than others. Generally, they are one of these four types.

Full Featured All SMT

First type is a fully featured connector with two rows of SMT pads. They are probably the most difficult to use for hobbyists, because there is no way to inspect/fix the inner pads, and at ~0.3mm pitch, those pads are very close together, and may short if your reflow process isn’t absolutely perfect.

If you are getting your boards professionally assembled, this may be ok, but there’s no need to risk it if you don’t need USB 3.0 SuperSpeed.

Here is one example: Korean Hroparts TYPE-C-31-M-05.

Full featured connector

Full Featured 1/2 SMT 1/2 TH

And then we have connectors where the back row uses through-hole pins instead of pads. They are probably easier, but the pins are very close together, and it seems like a huge hassle.

Example: JAE DX07S024XA8R700.

JAE DX07S024XA8R700

USB 2.0-Only SMT

And then we have connectors that omit all the pins not required for USB 2.0, and we end up with a connector with just one row of SMD pads, with reasonable spacing. This option I believe works the best for our applications, and my chosen connector is the Korean Hroparts TYPE-C-31-M-12 (LCSC part number C165948).

JLC has a lot of them in stock as of this writing, and offers them for $0.307 at qty 1, and a few cents to solder them for us.

Korean Hroparts TYPE-C-31-M-12

It has worked very well for me so far – perfect assembly quality from JLC, using KiCad’s built-in footprint for this connector.

I have never had to solder it myself, but because the pins actually extend past the housing (unlike many micro-B connectors), I feel this is probably pretty easy to hand-solder, too, if you are used to soldering QFPs.

Power-Only SMT

If we don’t need data transfer at all, there are even simpler connectors that only have power and the CC pins (so we can determine how much current we can draw). I have not tried them.

Example: Korean Hroparts TYPE-C-31-M-17. It’s $0.191 from JLC, so you save about 11 cents.

Korean Hroparts TYPE-C-31-M-17

How Much Current Can I Draw?

Continuous

If you have a USB-C power supply, just read the CC voltage, and refer to Table 4-36 copied above. If you want to support legacy power supplies as well with A-C cables, you also have to implement detection based on Battery Charging Specification 1.2.

Maxim has a guide on how to do that: https://pdfserv.maximintegrated.com/en/an/TUT5801.pdf

But it basically boils down to this (as I understand it) – there are 3 types of ports. Standard Downstream Port (SDP) which is data only with no high current capacity, a Charging Downstream Port (CDP) which is data + 1.5A, and a Dedicated Charging Port (DCP) which is 1.5A with no data.

One possible detection algorithm is to apply 3.3V to D+, and read D-. If it’s 3.3V, we have either CDP or DCP (otherwise SDP). Then we do the same, but reversed (apply voltage to D- and read D+). If D+ reads 3.3V, we have a bi-directional short between D+ and D-, which means we have a DCP. Otherwise it’s a CDP.

And remember that you have to multiplex it with data, if you also want to do data transfer.

If you want to support proprietary implementations, that’s a whole nother can of worms. Both Apple and Sony use resistive dividers on data lines that can be read with an ADC. Quick Charge I believe requires a dedicated controller.

Without either CC showing 1.5A/3A or BCS showing CDP or DCP, we have standard USB current, and that’s a lot more complicated. In this case you are allowed to draw 500mA only if your device cannot enumerate. If your device does enumerate, it must draw maximum of 100mA until negotiated otherwise with the host as part of the enumeration process (up to 500mA).

Startup Current

So either Type C current advertisement or BCS tells us the maximum continuous current, but what about peak current at plug-in, when all the capacitances charge up?

The spec allows for 10µF on Vbus (Table 4-3: VBus Sink Characteristics) or equivalent. What that means exactly is not 100% clear, but most people take it to mean that the initial current spike above the max continuous current allowed, when integrated over time, should be no more than 50µC, which is what a 10µF capacitor will draw at 5V. So if we have a huge capacitor behind a regulator, that would count, too, unless our regulator is current-limiting.

It does NOT mean we can’t have more capacitance than that. What that means is if we have more capacitance, we have to limit the inrush current so that they don’t appear as “naked” capacitance on Vbus (it may trigger overcurrent reset from the host). If we limit the charging speed of our capacitance to the max continuous current, we can have as much capacitance as we want.

Fortunately, there are many chips (usually called USB Power Distribution Switches) that can handle this for us. For example, the Diodes Incorporated AP2162/2172.

Current Slew Rate

This one is a bit harder to design for, and is probably more practically verified on the prototype rather than ensured by design. The maximum current slew rate (dI/dt) is 150mA/us, both on ramp up and down. This is the iLoadStepRate(max) in the spec, and the reason why it’s limited is because too much dI/dt can cause unacceptable Vbus voltage drop on the host due to inductance in the power supply path. If your design is exceeding this, it needs more capacitance (potentially requiring the use of a current-limiting switch, as described above).

Suspend Mode

A compliant device must implement suspend mode. In short, if there is no traffic on the data bus for 3ms, the device has 7ms to enter suspend mode where it must draw no more than 2.5mA. This may be difficult to implement if you don’t do USB yourself, but for example, the Silicon Labs CP210x USB-UART chip has SUSPEND outputs for this purpose. The microcontroller can monitor it, and turn into go into sleep mode if/when it goes high.

This requirement may be ignored if either CC indicates 1.5A/3.0A, or the host is a CDP/DCP port as detected through BCS.

PCB Design

PCB Design

It depends on what connector you choose, but in my case it’s pretty simple. All the shorting does make it a bit more complicated, but still easily doable on 2 layers, which is a requirement for this project due to cost-sensitivity (most of my other projects are 4 layers now).

For routing the data traces, standard rules apply (this is not specific to USB-C). They should be routed close together, with minimal vias and parallel runs of traces on another layer. Do we need impedance-controlled routing? Well, if you have a 4 layers board and you get free impedance control from your fab (like JLC), might as well do it. But whether that’s necessary or not depends on speed (edge rate) and trace length.

The general rule of thumb is if the edge rate divided by signal travel time is smaller than 6, we need to think about treating it as a transmission line (with controlled impedance).

USB minimum edge rates are 75ns for Low Speed, 20ns for Full Speed, and 500ps for High Speed. That gives us a maximum propagation time of 12.5ns, 3.33ns, and 83ps respectively. Velocity of propagation is ~0.6c, which gives us a maximum trace lengths of 2.2m, 60cm, and 1.49cm respectively, without having to worry about transmission line effects. In practice that means we don’t really need to worry unless we are doing High Speed (or we have very long traces).

So what if we need controlled impedance? We have to calculate the trace width and spacing, based on the dielectric our fab is using. For example, this is JLC’s calculator. USB spec requires differential impedance to be 90Ω, which means that given a trace space of 5 mil (that’s a free parameter), we need 8.1 mil traces with the JLC7628 dielectric, or 5.17 mil traces with the JLC2313 dielectric. Using their standard stackup for 4 layers 1.6mm boards.

Impedance calculator

Your result will be different depending on the fab, dielectric, and the stackup they use. There should always be a solid ground plane underneath the transmission line, and no other trace should be within 3x the width of the traces.

CC lines are low speed, and you can do whatever you want with them (within reason…).

Good luck with your designs and hope we will soon be in USB-C-opia!

Discussions on Reddit: https://www.reddit.com/r/diyelectronics/comments/mlyedi/guide_to_designing_with_usbc/

The victim

Disclosure: JLCPCB is sponsoring my projects, but I had already been a big fan of their PCB manufacturing/assembly services for a long time before that, and can recommend them without reservation.

Requirements

• 12V power
• Control 8x 12V lights at up to 1A each, with PWM at <= 20 kHz
• WiFi for time sync and remote override
• As small as I can make it so it doesn’t become an eyesore on my fish tank

Design

Main Controller

I am using the ESP32-WROOM-32 module for this project. It’s got a dual core 240 MHz 32-bit Xtensa CPU with an integrated WiFi controller. The module integrates all the external components required for the ESP32 chip – flash, crystal, and high frequency decoupling, as well as an impedance matching network and a MIFA PCB antenna. At about £3 (~US$4) each from Digi-Key, it’s also incredibly inexpensive for what you get.

Why? WiFi. Most of my IoT devices already run on WiFi, so using another standard would require getting another hub, and except in very low power designs and devices that need very long range, WiFi is a good choice for convenience (both in hardware and software setup), and data rate.

I can go with something like TI CC3000 with a separate controller, but since my microcontroller needs in this project are very modest (just PWMing 8 MOSFETs!), it’s easier and cheaper to just use the ESP32.

The circuit is basically a copy of the example circuit supplied in the datasheet. There’s really not much to it:

ESP32 circuit

Integrated USB->UART bridge

The ESP32 is programmed over UART, and I can either break out a UART header to attach an adapter cable to, or integrate a bridge IC so I can just use USB. Using a separate adapter is cheaper because I only need one of those, but the Silicon Labs CP2104 is $1.29 from JLC. I went for the convenience of only having to plug in a USB cable.

The CH340G is an even cheaper ($0.36) option from a Chinese company, but I wasn’t too worried about cost since I am only making a few of these, and I have successfully used CP2104 before. The CH340G also requires a crystal, which means larger board area, and of course you have to pay for the crystal (and compensation capacitors for the crystal). It’s also in SOIC instead of QFN. I didn’t think I would ever come to prefer QFN over SOIC when I was hand soldering my boards, but now that JLC is soldering them, the space savings with QFN is great!

The circuit is, again, mostly just a copy of the recommended application circuit in the datasheet.

USB circuit

MOSFET Choice

This board needs to do one thing – switch lights on and off (very quickly). If it can’t do that one thing well… I’d be sad. The choice of the MOSFET is crucial. I want to be able to pass 1A, and support up to 20 kHz PWM. We can often get away with a lower frequency, but there’s always the possibility of audible resonance, which is very annoying and impossible to predict, and can be solved by taking PWM frequency above audible range (20 kHz). So whenever possible, it’s a good idea to design the hardware for 20 kHz, and lower it to reduce switching losses if possible. I did end up running into the noise problem on this board, and had to run PWM at 20 kHz.

I know my requirements are modest, so I am primarily optimising for space and cost.

JLC doesn’t have the best parts search interface, but here are the basic MOSFET options:

I wanted something that’s a “basic part” because those are the parts already loaded on their pick and place machine, and don’t require an additional charge. They charge $3 for each type of extended part used.

Looking at the single N-channel MOSFETs, our choices are 2N7002 (not suitable because it’s a small signal MOSFET – designed to be fast but can’t take much current), and AO3400A.

As it turned out, the AO3400A is perfect. It’s tiny (SOT23 package), has an Rds(on) of 48 mΩ even with only 2.5V Vgs, and a maximum drain current of 5.7A (at Vgs=10).

I decided to drive the FET with ESP32 digital output instead of using a MOSFET driver. This is a somewhat risky thing to do, for two reasons –

1. We will only be driving the gate with 3.3V, and MOSFETs can pass more current and with a lower on state resistance when the gate is driven to a higher voltage.
2. The current output of a microcontroller digital pin is limited, which means we may not switch the MOSFET on/off fast enough (that requires charging/discharging the gate charge).

So we have to do the math to prove to ourselves that it will be fine. We start with the datasheet.

First thing is to verify that we are below the absolute maximum Vds rating. That’s 30V here, and we are fine.

Then we look at how “turned on” the MOSFET will be at 3.3V.

Figure 1 (Id vs Vds) tells us all we need to know.

Id vs Vds

It gives us Id vs Vds plots for different Vgs options. Ideally we want the MOSFET to behave like a resistor when on, and that means we want to stay in the saturation region, and not the later linear region, where increasing voltage over the MOSFET does not result in higher current flow (ie. it’s no longer behaving like a resistor).

It does not have a plot for 3.3V, so we go down to the next conservative option, which is 3V in this case (because we know that the MOSFET will be “more on” at 3.3V than 3V). We see that it’s totally linear until about 30A, and that’s way more than plenty (remember that we only need 1A).

We can also work out the Rds(on) from the slope of the linear region, but it’s easier to consult another graph –

Rds(on) vs Vgs

Here we see that for Vgs = 3.3V, we are looking at about 22 mΩ at 25C, and about 35 mΩ at 125C. I know this circuit will mostly be kept around room temperature, so I’ll use 25 mΩ.

Now we can calculate power dissipation in the MOSFET in on state –

P = I^2 * R, for I = 1A, and R = 0.025Ω. We get P = 0.025W. This MOSFET won’t even get warm!

With power dissipation out of the way, let’s look at how fast we can switch the thing, and that involves looking at the various parasitic capacitances that affect the gate, because we have to charge and discharge them every time. Now there are much more complicated models available because MOSFET gates don’t actually have constant capacitance (if components that have constant resistance is called ohmic, can we call this non-faradian?). This is due to the Miller effect. You can learn all about that in this nice tutorial from Microsemi if you are interested. But unless we are working very close to the limit, we can use a vastly simplified model – total gate charge (Qg), which is the total charge that needs to be injected into the gate, divided by Vgs gives us the gate capacitance, and we just think about charging/discharging that capacitance.

Figure 7 tells us what we need to know:

Vgs vs Qg

Here we see that at Vgs = 3.3V, we get a gate charge of about 5nC, which means a gate capacitance of about 1.5nF. Notice that this is tested at Vds = 15V and Id = 5.7A, which is not quite how we will be operating the FET. We have a lower Vds (12V), and a lower Id (1A), so our actual Qg won’t be exactly the same as in the figure. Generally speaking, a lower Id increases gate charge, and a lower Vds reduces it. This would be something to look into if we get close to the limit. We’ll use the value straight from the figure for now. In practice, if I am getting close to the limit, I will just add a gate driver instead for the peace of mind. My go-to chip for this is the MCP1416. It’s tiny, cheap, has a very wide operating voltage range, gives me a nice 1.5A gate drive, and is very easy to use.

How fast can we charge it? The ESP32 datasheet says we can source 40mA, and sink 28mA before the output voltage changes significantly (from 3.3V to 2.64V and 0V to 0.495V).

Ioh and Iol

For simplicity we will use a 100Ω gate resistor, which would limit the current to about 33mA (3.3V / 100Ω). So now we need to figure out how fast we can charge a 1.5nF capacitance through a 100Ω resistance, and this is an application of the basic exponential capacitor charging equation, where the time constant τ = RC. That’s 150 nanoseconds in this case, to charge to 63.2% of the final value, and and 300 nanoseconds (two time constants) to charge to 86.5%. That’s a good enough approximation of the rise/fall time for our purposes.

Remember that we were aiming for a PWM frequency of 20 kHz, which has a period of 50 microseconds. In general, we want the rise and fall time to be less than 1/10 of the period, or 5 microseconds in this case. We are plenty fast enough. In fact, we are good for up to about 300 kHz, but there’s really no point going above 20 kHz.

At $0.075/FET, looks like we have a winner! This is a very impressive MOSFET. Low Qg vs low Rds(on) is the major tradeoff in MOSFET design, and usually you can’t have both. This FET seems to have done the impossible, and I don’t think FETs like these existed say 20 years ago.

The circuit. We also added a pull-down resistor to make sure the FET is off at power on, before the microcontroller starts controlling the gate. I also have a flyback diode. That’s probably not necessary in this case, because lights are not typically inductive, but I’m thinking I may want to re-purpose this board to drive motors or solenoids later on, and the diodes are only $0.03 each, and someone else is soldering them.

Power Supply

Power supply circuit

Here we have the power supply. The two Schottky diodes allow for two sources of power – 12V main supply or 5V USB Vbus (which ever is higher will supply the current). This allows me to program and debug the board without 12V power connected.

I am using a linear regulator, which is horribly inefficient going from 12V to 3.3V, but we are drawing less than 100mA at 3.3V, and the lights are drawing about 4A total. Insignificant at the end of the day.

The only decisions to make here are the input and output capacitors. Followed what the datasheet recommends. Very important for the stability of many regulators.

PCB

And finally we get to the PCB design. I designed this as a 4 layer board to minimise size. As an aside, I almost never make 2 layer boards anymore. JLC can make 5x 100mm by 100mm 4 layer boards for $7. Why make my life more difficult trying to route this on 2 layers (and suffer worse signal integrity)? My time is worth a lot more than the $5 that would be saved (they charge $2 for 2 layer of the same size).

The ground plane first:

Ground plane

The middle section is for the ESP32, and the outer ring has the load-switching MOSFETs (which handle the return current from the loads). This is a star grounding design to prevent load return current (which is on the order of 4A – very high for the size of the plane) from passing under the ESP32 and introducing ground noise there.

The power plane looks similar:

Power plane

But the two parts of the plane aren’t connected. The inner part is for 3.3V, and the outer part of 12V.

And finally the signal layers:

Signal layers

This is quite dense routing, but pretty straight forward. I used it as an exercise to see how small I can make things, and most of the 50x60mm board is taken up by connectors. All the passives are 0402. Hey, someone else is soldering them!

Assemble and Test

A few days later, I got the boards in the mail from JLC, and soldered the connectors, ESP module, and the USB port myself.

(Almost) assembled

Does it work? Yes!

Tested

How about the MOSFET gate rise time that we spent so much time calculating?

PWM scope shot

Beautiful waveform at 20 kHz. 364ns rise time and 297ns fall time. Almost exactly what we calculated, even though we used a vastly simplified model that would have driven a power systems engineer bananas.

And just for fun, this is what the waveform looks like if the edges are too slow for the frequency. This is at 500 kHz.

500 kHz PWM

Here we see that the rise and fall times take up significant portion of the period, which means the FET will spend a lot of time in the saturation region, where they are partially on. We want the MOSFETs to be in fully on (aka triode or linear region) or fully off (aka cutoff) regions as much as possible, since there is very little power dissipation in both.

P = VI. When the FET is fully on, the voltage is very low (0 for an ideal FET). When the FET is fully off, the current is very low (0 for an ideal FET). During transition is the only time where there is a significant voltage drop across the FET as well as a significant current passing through it.

I like to look at all my boards with an infrared camera to see if anything is unexpectedly hot.

IR image

The MOSFETs are not heating up at all, even after extended operation. Of course, we knew that already from the calculations. The regulator, on the other hand, is getting quite toasty.

You can see the whole system in operation in the video at the beginning of the original post.

Files

All files below are hereby released under CC BY-SA.

KiCad: https://github.com/matthewlai/WiredHut/tree/master/hardware/light_control/light_control

I have been spending a lot of time working on microcontroller power optimisation recently, and not having a current probe for my oscilloscope has been quite inconvenient. Working with current optimisation without a current probe is like designing a circuit without an oscilloscope – shooting in the dark.

Can I Just Buy Something?

Yes, but commercial current probes are very expensive and unwieldy. For example, this is (as far as I can tell) the lowest end current probe from Rigol (known for extremely cheap test equipment):

Rigol RP1001C

It’s a hall effect probe to be clamped around a conductor, and requires a separate power supply. All for the bargain basement price of £791 (~US$1000), which is a bit more than double what I paid for my oscilloscope! It’s also very bulky and requires its own power supply.

Now if you need the specs they offer (100A peak, 300 kHz bandwidth, and no voltage drop), that’s probably the way to go.

But my requirements are much more modest – I only realistically need up to 10A (<1A 99% of the time), 10 kHz, and don’t mind a reasonably small burden voltage since the boards I work with all have onboard regulators anyways.

So I set out to build something that is at least an order of magnitude cheaper, and also an order of magnitude smaller.

The Theory

The general idea of a shunt-based current sensor is very simple:

Shunt current sensor

We put a resistor in series with the load, and measure voltage drop across the resistor, and use V = IR to work out current through the resistor (and therefore the load). Nice and simple, but two problems:

• We want (Isense+ – Isense-) to be large so we can make a low noise measurement, but that means we have a high voltage drop to the load that depends on the current (basically we are increasing the source resistance of the power supply), which we want to minimise. The voltage drop due to current measurement device is called burden voltage.
• The voltages are on the +Vs side, which are hard to measure (this is called high-side sensing). Why not have the sensing resistor between the load and ground? It’s possible, but if the load is a circuit that needs to communicate with another circuit referenced to the same ground, we really don’t want to “lift” the ground when the load draws current, which would be the case here. That’s why the vast majority of applications use high side sensing. Generally supply voltage dropping is less of a problem for circuits than ground rising.

The solution is to use a differential amplifier to amplify the voltage across Rsense, and output an amplified voltage difference relative to ground. This solves both problems – the amplification allows us to use a very small Rsense and have a very small voltage drop, while still getting a large sense voltage for measurements, and shifting the sense voltage to be relative to ground makes it easier to measure.

Component Choices

This is a very common application, so although you can use a generic differential amplifier (or instrumentation amplifier), there are many products designed and optimised specifically for this use, with most of the necessary external components integrated into the chip, usually sold as “current-shunt monitors/amplifiers”, and it’s a good idea to use them. I chose the Texas Instruments INA213 current shunt monitor, because it’s cheap (US$0.587 each from JLC), has a very low offset voltage (Voff) of ±35 µV, which allows me to minimise the burden voltage by using a very small shunt resistor. There are also versions with high precision integrated ADC with digital (either I2C or SPI) output, and they are good choices if you are integrating current sensing into your microcontroller project, but since we are reading with an oscilloscope, we will go with a standard voltage output device.

Voff can be thought of as a voltage error on the input. The larger the Voff, the larger the Rsense we need, to maintain the same signal-to-noise ratio (SNR). Therefore, Voff is one of the most important parameters for a differential amplifier.

The INA21x series comes in many different gain options from 50 to 1000. Generally, higher gains allow the use of a smaller resistance and hence lower burden voltage, but increases noise, and decreases bandwidth, since amplifier bandwidth is usually inversely proportional to gain – see Gain-bandwidth product%20and%20vice%20versa.). That is the case here as well. The 50x gain version I chose has an advertised bandwidth of 80 kHz typical, whereas the 1000x version has a bandwidth of 4 kHz. I chose 50x gain because bandwidth is more important to me than burden voltage, which is already low enough at 50x, which would give me a 1V output from a 20 mV burden voltage. My circuits don’t usually care about anything as small as 20 mV.

The INA21x series can also be powered by anything from 2.7V to 26V, which covers all the supply voltages I use. That means I can make the setup simpler by trading flexibility for convenience and just power the amplifier from my power supply.

Circuit Design

Here is the circuit design:

Schematics

Pretty straight forward. I am using a 20 mΩ resistor, so that at a maximum current of 10A, I get a voltage of 200mV, which amplifies to 10V, giving us a nice 1 V/A relationship on the output. 10A ^ 2 * 20 mΩ = 2W, so I got a 2W rated resistor.

I used two INA213 devices because I want to be able to measure both positive and negative currents (eg. during motor flyback), so they are wired identically, with just SENSE_N and SENSE_P swapped. This is technically not necessary – if you look at the datasheet, it says the device is capable of bi-directional measurements. The way that works is by wiring REF to (usually) Vdd/2, so if the output voltage is higher than Vdd/2, it’s positive, and vice versa. I didn’t want to do that because that would make it harder to read oscilloscope output, and also harder to get the oscilloscope’s variable gain amplifier to amplify small outputs (since they always amplify relative to ground). The INA213 only costs US$0.587 each, so the easiest solution is to just use two amplifiers. Where a unified trace is needed, I can probe both, and use MATH function on the scope to take the difference. That does require the use of two channels – I am not too worried about that because I have a 4 channel scope. If you want to save a channel, you can also build some additional circuit (eg. charge pump inverter) to generate a negative supply, and power the INA213 with +Vs and -Vs, with REF tied to ground. I thought about doing that, but it would reduce maximum supply voltage to 13V, and having 26V supply range is more important to me. Of course, you can also add a regulator, but then your minimum supply voltage will go up from 2.7V, due to regulator dropout, and I really want to support 3.3V supply, which makes it difficult. At the end of the day, this is an extremely cheap device, and I can always make another one with different design decisions should it become necessary.

PCB Design and Gotchas

PCB design

PCB design is the hardest part of this project. We are working with very low voltages, so we need to pay a lot of attention to minimising noise. I have the input and output connectors on the left, Rsense and the two amplifiers on the right, with the outputs brought out to test terminal posts for easy probing. I also have ground and Vsupply broken out into test terminals. Ground is especially important – for precise measurements we always want to ground the probe as close as possible to the test point.

Let’s talk about ground first. This is the ground plane:

Ground plane

The entire back layer is ground, but I have a thin slot splitting it down the middle, only connected at a tiny point at the bottom. This way the left side is used by the load (I want a very low impedance connection from input ground to output ground), and the right side is ground for the amplifiers. It’s important to split them to ensure that load return current doesn’t go under the amplifiers, because that would lift the amplifier ground, and load transients may inductively couple to amplifier signals. Not something we want for precise measurements! This is called star grounding topography. Altium has a very nice article on this for further reading.

Now back to the front side:

Front side

Here we have two copper pours to connect input supply voltage to Rsense, and from Rsense to output supply voltage. Why pours? Because we want very low impedance paths, as well as provide some heatsinking for Rsense, which will get very hot if we do actually push 10A through it! But again, I don’t want to go over to the amplifier side, due to potential for introducing noise.

Note that the amplifiers are connected to Rsense using the Kelvin sensing technique. This is very important when we are amplifying voltages across tiny resistances like what we have here. We have to ensure that the load current isn’t going to flow through any part of the trace connecting amplifiers to the resistor pads. A Kelvin connection ensures that.

That is it for the PCB!

Getting It Made!

I have the PCB manufactured and (mostly) assembled by JLCPCB, who has been amazing and I can totally recommend.

Full disclosure: JLCPCB is generously sponsoring my projects, but I was already a big fan of them before they reached out, and I would never recommend a company that I wouldn’t use if I had to pay myself.

If you are wondering how to use their SMT assembly service with KiCad, I have written a tutorial and a script for that. It’s super easy!

How much does it cost? US$27.71 + shipping for 5 boards, assembled, and including components!

PCB cost

10 days from order to delivery here in London, UK, but I combined it with a much more complex 4-layer assembly order, so it may have been faster if this was ordered on its own.

While waiting for the boards to arrive, I designed a box for it in Fusion 360, and printed it on my trusty Prusa.

Render. Not actually wood, but wood looks more interesting rendered

And finally:

Assembled boards

Connectors and test terminal posts soldered. Banana for scale.

Put in the box

All wired up

Does It Work?

First, I set the scope channel to current mode at 1A/V (this is purely a display setting – the hardware doesn’t do anything differently in current mode), and the probe to 1X attenuation. 1X attenuation is not usually recommended because of the much lower bandwidth (10 MHz for my probes), but does give you lower noise. In this case it makes sense to use 1X because the amplifier only has about 100 kHz bandwidth anyways.

In current mode with the attenuation set correctly, all the measurements that used to be voltage are now given in current!

Channel settings

ESP32 Sleep. ~0mA deep sleep, 60mA wakeup for about 400ms during boot, then about 125mA during WiFi association, a few spikes to 500mA to transmit a few packets, then back to deep sleep.

How much bandwidth do we have? For this test I have the ESP32 PWM a 44 ohms resistance (220//220//220…) at 20 kHz, with bulk decoupling capacitor removed.

PWM.

Here we see a rise time of about 2.4 µs. That corresponds to a -3db bandwidth of about 145 kHz. Quite a bit higher than the advertised 80 kHz.

So it seems it does everything I want it to do, while being less than 1/10 the cost and 1/10 the size and clutter of a proper current probe.

What About Cost?

PCBs: $27.71

3D printer filament: 12.4g (~$0.48)

Test terminals: ~$1.00

Supply terminal blocks: ~$2.00

Total: $31.19 + various shipping. And you get 4 leftover partially assembled boards. If you assemble them and give/sell them to your friends and neighbours, that’s about $9 each.

These specs for this price? I am very happy. This is a good solution if you want current measurements faster than a multimeter, but not as fast as a proper current probe.

Files

All files below are hereby released under CC BY-SA 4.0.

KiCad: https://github.com/matthewlai/CurrentSense/tree/master/current_sense

Fusion 360 Case: https://a360.co/3fQznZr

Want Your Own?

Send JLC these files: Gerbers JLC BOM JLC Component Placement

Unfortunately I cannot provide any warranty or promise support. If you have questions, leave a comment below and I’ll try my best to help.

The only other components you need are the Phoenix terminals, 1.4mm test terminal posts, and access to a 3D printer if you want a case, as well as 4x 10mm M3 bolts, and 4x M3 nuts.

Why?

This is what I started with:

Original setup. The green tint is due to tannin build-up, which I have since decided to filter out.

It’s… fine, but the lighting left a lot to be desired. Lighting is not just aesthetic – those are real plants, and plants require light for photosynthesis. A lot more light than most people imagine! In a tank of this size, with plants with moderate light requirements, it’s generally advisable to aim for about 40-50W in LEDs (or ~3000 lumens, if we want to get technical). If you have worked with LED lighting before, you probably think 40-50W is an absurd amount of light for such a small space (equivalent to about 400-500W incandescent), and you would be right.

I initially got two of these lights. Advertised for either 18W or 25W each, depending on whether you trust the title or the description.

Original lights

I grew suspicious, and measured the power draw at the wall – 15W each. With a 80% efficient power adaptor. That means I was really only getting about 12W each. Not nearly enough! I did what any self-respecting engineer would do and left a review on Amazon. So I needed new lights, and instead of taking my chances with another cheap and probably falsely advertised light, I decided to just take it into my own hands, and make a much nicer one. MakeColourTexture

Design Decisions

What kind of lights to use? I originally planned on building my own out of COBs. But that proved expensive, and I would need to sort out lenses myself and that’s a lot of work.

Instead I decided to go with MR16 (GU5.3) lights. They run on either 12VDC or 12VAC, and are widely commercially available, and there are dimmable versions… sort of.

MR16/GU5.3 lights

The low voltage is important because I don’t want to kill myself or my fish if any part of the system falls into the water. Unfortunately this rules out the Philips Hue, which would have made this project 10x simpler.

I ended up deciding on 4x 2700K 8W warm white and 4x 6000K 6W cool white lights.

There are no smart 12V LED lights, so I had to build my own controller.

Controller

The controller

ESP32-based so it can be controlled remotely (and firmware upgraded remotely!), and also automatically sync time. As it turns out, keeping accurate time locally, at low power, and over extended time, and at low cost, is a pretty difficult problem. Since we need WiFi anyways, I decide to not bother with that, and just have it sync with an NTP server every day. This way I also don’t need to worry about having a way to set the current time, which we need the current time to do simulated sunrise/sunset.

See this follow up post for a deep dive on the electronics.

Testing setup. It is BRIGHT!

And in infrared

The switching MOSFETs aren’t getting hot at all, but the 3.3V regulator powering the ESP32 is. It was going up to 70C before I downclocked it from the default 240 MHz to 80 MHz.

The Frame

… is cut out of plywood with a jigsaw. And I am not very good with jigsaw. Oh and a few coats of yacht varnish for waterproofing just in case.

The plywood frame

I would have design a more organic shape and laser cut it instead, but I no longer have access to a laser cutter thanks to COVID-19 (just Google it if you are reading this decades from now and don’t know what I am talking about… and Google was a popular search engine in the 2020s… use whatever is popular now), so I had to cut it out with a jigsaw like a pleb.

Feet so it can stand on the aquarium. Designed in Fusion 360 and printed on my trusty Prusa

Printed some brackets to mount the MR16 fittings to the frame.

And with the electronics mounted. Also in a printed case. Lots of wire extensions involved, but heat shrink solder sleeves made it a very easy job. Also free waterproofing!

Result

As you can see in the video at the beginning of the post, it worked out quite well. The lights don’t dim as much as I had hoped, and I may be designing a new controller in the future that does AC chopping (which is probably what the lights need) for better dimming, but otherwise, it turned out almost exactly as I had envisioned, so I am pretty happy about that.

Files

All files below are hereby released under CC BY-SA.

KiCad files: https://github.com/matthewlai/WiredHut/tree/master/hardware/light_control/light_control

esp32-arduino firmware: https://github.com/matthewlai/WiredHut/tree/master/firmware/fishtank_light/main

Fusion 360 model for the legs: https://a360.co/3abuvg5

BlinkenLights!

I don’t want to use commercial planters because most of the ones sold here use cheap pressure-treated softwood, and those don’t last very long. I want to use a naturally rot-resistant hardwood, and although they are also available commercially, they are extremely expensive for the sizes I need.

So of course I decided to make my own.

This is made out of Iroko, which is an African hardwood that is naturally resistant to rot (because of its oil), so it doesn’t need to be treated or coated in anything even for prolonged contact with soil (as is the case here). Apparently it’s also believed to have super-natural properties in Yoruba folklore. How cool is that? It’s a beautiful wood.

Enjoy the video!

First prototype, designed by my friend Forest in Blender. The tutorial will take us through the second design and attempt.

Why?

• Silicone can be used to make all sorts of things, but perhaps the most popular application is sex toys. There are huge variations in personal preferences, and if you are designing your own, you can make it exactly how you like it. Have a really good toy that’s just 2mm too wide? Make your own version!
• You know what’s in there. 100% platinum-catalysed silicone is the holy grail material for safe insertables, and since consumers start asking for it, unscrupulous marketing people at sex toy manufacturers started getting creative. Most that are sold as silicone isn’t actually silicone, but TPE or other porous and unsafe materials.

What?

The traditional silicone casting process is to create the positive first (eg. carving it out of wood), making a mould around it out of plaster, and then pour silicone into the plaster mould, making it a two step process. In this case because we are 3D printing, we can just print the mould directly and skip the first step.

Print a mould, clamp the parts together, pour silicone, and remove mould. Easy! But of course, the devil is in the detail…

What Do You Need?

• A 3D printer and filament. Type of filament isn’t important. I’ve used PLA and PETG and they both worked well. Dimensional accuracy is important. Don’t use a filament that warps (ABS, Nylon, PC, etc).
• Silicone. Be sure to get platinum-catalysed silicone. It’s more expensive than tin-catalysed stuff, but much more stable, and the curing process doesn’t produce byproducts. Most people use Smooth-On Dragon Skin because it’s skin safe (it’s marketed for use in special effects, where there is often prolonged skin contact). There are 3 different hardnesses to choose from – 10A, 20A, and 30A. I am using 20A and it seems to be pretty standard sex toy hardness (slightly on the soft side). You can get a 1kg “trial” set for about £32.
• Art and Craft Epoxy Resin. We only need a little bit.
• Disposable cups for mixing – 500+ml recommended (more than 4 times the volume of the objects you want to make).
• Disposable chopsticks or similar for stirring.
• Small cheap brushes – makeup brushes work well.
• Cable ties (zip ties).
• (Optional) Silicone mould release spray. Will make it much easier to remove the mould after casting. I did my first one without it, and was able to get it out, but there was a lot more cursing involved.
• (Optional) Silicone Colourant. If you want any colour other than cloudy white (see picture at the beginning of this page). The Smooth-On colourant isn’t cheap, but it’s highly concentrated, so you only need a little bit, and each pot is enough to make many objects. I’ve heard people having success using soap pigment or watercolour, but keep in mind that the platinum curing process is very easy to disrupt if your pigment happens to have wrong additives. Sulphur is the big one that will completely inhibit the curing process.
• (Optional) Vacuum degassing setup. If you don’t degas, there will be many small bubbles in your finished product (see picture at the beginning of this page). It’s mostly an aesthetic issue as the bubbles don’t change the texture, so if you are fine with that it’s ok to go without. When choosing a degassing set, the pot has to be big enough for your mould, and the pump basically doesn’t matter as long as it can get to -1 bar (full vacuum). Single stage pump is fine. We don’t need a fast pump since, unlike degassing resin for example, silicone has a much longer pot life. More information.

Design

First you need a design for the object you want to cast. For more organic designs Blender is a good choice. For more symmetrical designs Autodesk Fusion 360 is one option. You can also scan an object you have, if you have access to a 3D scanner. There are also sites like http://dildogenerator.com that will give you a downloadable model.

Regardless of how you choose to get your design, we’ll be using Autodesk Fusion 360 to create the mould. It’s free for hobbyist and startup use, so go download that. I’ll wait!

I won’t write a detailed tutorial for Fusion 360 here because Autodesk made very good tutorial videos. Even if you have never done any 3D modelling before, it shouldn’t take more than 2-3 (fun) hours to learn the basics, and we only need the basics for this. Go do that and come back when you are ready! Rest of the tutorial assumes you have basic knowledge of Fusion 360.

I made a quick design here, modelling a random toy from my drawer:

Start with a sketch of the profile to revolve. I used a spline here to define the shape. Be sure to leave a flat area underneath for filling. Oh and it’s probably a good idea to make sure the tangent at the topmost point is horizontal, unless you want a pointy tip.

Revolve.

Another sketch on the bottom face for cutting. More splines and mirroring.

Extruded cut for the boat-shaped bottom.

Fillet to make the bottom edges rounded.

Right click on the body (in the object tree) -> properties. That will give us the volume. Write that down as we will need it later to calculate how much silicone we need. Here I have 7.19e4 mm^3, which is 71.9 ml.

Now we have the object we are casting. If you are getting your design from another source, just import the STL instead and continue from here. If you have a very high poly model (>10000 triangles), it’s probably a good idea to use Meshmixer to simplify it to 10k triangles. This is because Fusion 360 is a BRep modeller, and cannot deal with meshes very efficiently. It shouldn’t affect the quality of the final product if you do it right, since silicone pouring doesn’t have anywhere near that kind of resolution.

Create a sketch through the middle of the object (if you have imported an object so it’s not aligned with the default planes, use construction planes to get the plane you need). This will be where the mould splits into two. It should be a rectangle that covers the whole object, and with the bottom edge coincident with the bottom of the object (this will be the fill hole where we pour silicone in). Also add some geometry for aligning the two sides of the mould. I am using circles here, but you can use whatever you want.

For each alignment post, make two concentric circles. The outer one will be used to make the hole, and the inner one will be used to make the post. Due to 3D printing tolerance, we can’t use the same circle for both. A gap of 0.075mm works well for me, but I have a very well tuned Prusa i3 MK3S. You may want to experiment to see what works well for your setup.

Extrude with holes to one side. Make sure it’s thick enough to cover the whole object, and use “new body” mode so it doesn’t get joined to the object.

Extrude the other side, with the posts to go into the holes.

Chamfer the corners of the mould to reduce the risk of corners lifting.

Use “Modify -> Combine” to cut the object out of the mould (use the object as the “tool body”).

That’s all! Export and print the mould. 2 shells and 15% infill works well for me. I recommend printing one side at a time, since they do take quite a while (6 hours per side in my case).

Making the Thing!

Mix some epoxy as per the instructions. We only need a little bit.

(Untested: if you have a vacuum chamber it may be a good idea to put the mixed epoxy in to get rid of the bubbles at this point)

Use the makeup brush to brush a thin layer of epoxy onto the negative parts of the mould. This is to cover up the layer lines from 3D printing, so they won’t transfer to the final product. This is important because if they do transfer, we’ll get bacteria traps that won’t be possible to clean. Make sure you have complete coverage but don’t go overboard with the coating – a thin layer is all we need, and surface tension will do most of the work for us.

Wait for the epoxy to cure. It will take 8-12 hours at typical room temperature. You may think a thin coating like this should cure very quickly, but counter-intuitively, a thick layer would actually cure faster than a thin layer. This is because the curing reaction is exothermic (releases heat), which further speeds up the reaction. With a thin layer the heat generated quickly dissipates, and you get less of this effect. You can put it in an oven to speed up curing if you want, but be careful not to melt the plastic, especially if you are using PLA. My oven goes down to 40C (104F), and that’s what I would use.

Once that’s done…

Give both sides of the mould a good spray of the release agent if you have it. This will make removing the mould much easier later on.

Secure the two sides together with cable ties. You can use whatever method you want to hold them together, but it has to be pretty tight, and also keep in mind that it will have to fit into the vacuum chamber later if you are planning on degassing, so no huge clamp setups.

Now we are ready to mix the silicone. Remember the number we got above? 71 ml is the volume of my final product, and I mixed 100 ml (50g of each part) because I know some will be stuck to the cup. That turned out to be more or less the correct amount.

If you are very observant, you may have noticed that the two parts to the silicone actually have slightly different density. So should we mix 1:1 by weight or by volume?

It doesn’t actually matter. It will be fine as long as the ratio is more or less right, because the second part is just a catalyst (so if you used a bit less, you get a slightly slower curing, and vice versa).

I am mixing by weight here because I have a scale.

If you are planning on degassing, the cup should be at least 4x the size of how much you are mixing, because it will foam and expand to about 3x the starting volume during the degassing process.

If you are using colourant, add it now. A very small amount will be enough. I use a chopstick to stir the pot, and just used the amount that’s stuck on the chopstick. put it in the mixing cup, and zero the scale.

Pour the right amount of Part A into the cup. The order is important. If you are using a colourant it has to be mixed with Part A before Part B is added.

Mix thoroughly.

Zero the scale again, add the same amount of Part B, and mix thoroughly again. If you are not degassing, try not to stir too many bubbles into the mixture, but at the same time, you have to make sure it’s thoroughly mixed. If you are degassing, it doesn’t matter. We will be getting the bubbles out later.

At this point the clock has started. How much time you have depends on the silicone you are using, but it’s 25 minutes in my case, so the rest of the steps have to be completed within 25 minutes. It’s plenty of time so there is no need to rush, but also don’t go take a bath.

If you are not degassing, skip to the pouring step. Otherwise read on…

First make sure your vacuum pump has the right level of oil between min and max.

Place the mixed epoxy into the chamber, close it, close the re-pressurising valve, and turn the vacuum pump on.

You should be able to get to a good vacuum level (pressure too low to detect) in less than 2-3 minutes. If not, either your pump is broken (does it have enough oil?) or the vacuum gauge needs “burping”. Or maybe you have an air leak somewhere?

You’ll see the silicone rise at some point to about 3x the original volume, as all the bubbles are drawn out and expanded to hundreds of times their original sizes due to the vacuum. Then it will suddenly collapse back to the original volume as the bubbles pop. Continue vacuuming for 90 seconds, then turn off the pump, re-pressurise, and take the silicone out.

Smooth-On’s degassing instruction video.

Finally, we can pour the silicone into the mould. Here I poured it all the way to the top, but in hindsight it’s probably a better idea to pour to 1cm (half an inch) from the top first if we are degassing. If you are not degassing, just pour to the top, and that’s it!

Put it into the vacuum chamber again. This time we will be removing any bubble introduced in the pouring process.

Vacuum until you stop seeing bubbles. It will be much slower this time, as most of the bubbles have already been removed. As you can see, I have a bit of a spill here as the bubbles came up, because I filled all the way to the top.

De-pressurise and the silicone will settle into a clear, bubble-less state. You may have seen a few bubbles left still when you turned the pump off, but remember that those bubbles are hundreds of times bigger than they would be in normal pressure, and probably not visible.

Wait for it to cure. How long you have to wait depends on your silicone, and you can speed it up by putting it into the oven at a very low temperature. Again, don’t melt your plastic… I am using 45C in fan mode.

Finally, pry the mould open with a flat head screwdriver. Just slot it in and turn, going all around the edges until it opens up. Curse liberally if you did not use mould release.

Tada!

Remove the extra bits of silicone that went outside of the negative, and that’s all!

Good luck! For next time, I’ll probably get some long screws for both alignment and holding the mould together instead.

Here is my Fusion 360 file if you want to take a look. You can also import it into Fusion 360 for editing: https://a360.co/32sVLoJ

Everything in this blog post excluding the first image (I do not own copyright to the design), and including the Fusion 360 project, is hereby released into the Public Domain (or, if you prefer, licensed under Creative Commons CC0). No Rights Reserved.

TLDR: Click here.

A Bit of History

I remember when I first started making PCBs in ~2010, our low spec (8 mil min traces / 8 mil min spacing) 2-layer boards costed $133 for 4 copies. Special academic pricing.

There were services like Sparkfun’s BatchPCB and OSH Park that were quite a bit cheaper, but generally took about a month to deliver, as they batched together designs from many customers on each panel to amortise the cost. Great if you are very patient, but not very useful if you have any deadline.

And then the Chinese prototyping services popped up, I think around 2012, and started getting popular. Of course, most production PCBs had been made in China for at least a decade at this point, but I believe this is the first time Chinese companies started targeting the low quantity prototyping market. If my memory serves, Seeedstudio was the first with their Fusion PCB service, and ITeadStudio was, as always, the first copycat. They offered about the same specs as the fabs we have been using, but for $10-$20 per 10 boards, though they still had the problem of long lead time (and high shipping cost from China if you want your boards fast).

Fast forward a few years to 2019, and now there are many similar services out there, offering even lower prices (as low as $2 for 10 boards!), very fast turnaround (24-72 hours), and very high specs (5/5 mils or even 3.5/3.5 mils). Very interesting options have also become available – ENIG finish, different substrates (eg. flex or aluminium for high power applications), different copper thicknesses, and 4+ layers for reasonable prices.

I have tried most of them at least once, and they are largely interchangeable unless you want very specific options. PCB prototyping is now a commodity, so now they are looking for other ways to differentiate, and assembly seems to be one such area. As hobbyists we have already given up making PCBs at home. Wouldn’t it be great if we can get someone to do the soldering as well?

I believe Seeedstudio was again one of the first to offer this service, but they assemble low quantity PCBs by hand, and reviews were scathing – bad solder joints, missed parts, parts installed in wrong orientation, etc. That’s why I never tried it. It didn’t seem like we would get high quality assembly until someone starts offering automatic pick-and-place for low quantity boards.

I was very excited when JLC started offering just that recently. They have a bunch of pick and place machines already set up with 600+ common components, and they can also load up new components for you at $3/component type, from their 30k+ components library. They are owned by the same company as LCSC, the biggest electronic component distributor in China, so that’s how they can get such an extensive library of components. Of course, with Chinese-sourced components there is always a chance of fakes. Time will tell how big of a problem that is – at least LCSC and JLC are very big companies that do have pretty good reputations they can lose, so it’s still not like ordering random components from eBay.

As far as I can tell their entire process is automated (besides presumably loading up reels that they charge $3/each for), and that also comes with downsides – no thru-hole components, and you can only use components they have in stock (unlike most assembly services, you can’t supply components for them to use). Unfortunately they don’t have any connectors in their library, so if you want a USB connector for example, you still have to solder that yourself. The reason they gave is that they panelise boards for assembly, and board-edge connectors make it difficult. However, besides that, their library is pretty extensive, with even some stock of high end microcontrollers like STM32F7, and lots of STM32F4.

The Process

I have developed a process for using their service with KiCad, and wrote a script to generate the files they need, so here is a walkthrough.

1. Design your board as usual, but…
   • Make sure all the SMT parts you want assembled are on the same side.
   • Choose parts from their library. Add the Cxxxxx code to your components in Eeschema by adding a custom field (call it anything you want). That’s what my script will pick up later on. Anything that doesn’t have a Cxxxx code won’t be assembled.
2. Once you are satisfied with your board design, go to Eeschema and run “Tools -> Generate Bill of Materials” to generate a BOM in any format/plugin. We don’t actually need the generated BOM file, but this process will produce an intermediate netlist file in XML format that we need later (not the same as KiCad’s standard netlist).
3. Go to Pcbnew and run ‘File -> Fabrication Outputs -> Footprint Position (.pos) File’.
   • CSV format, mm unit, and ‘single file for board’
4. Plot gerbers as per usual for PCB manufacturing – all copper layers, front mask, back mask, front silk, back silk, Edge.Cuts (for board border). Not sure if the paste layers are needed (given they are doing the assembly), but I include them in my zip file anyways and they don’t seem to mind.
5. Run my script and give it the project directory. It will look for the files it needs in the given project directory and all sub-directories, and let you know if it can’t find anything.
   • Follow the instructions here to install and run the script: https://github.com/matthewlai/JLCKicadTools
   • If all goes well, the script will tell you where the BOM and CPL files generated are (inside your project directory). If not, read the error message and fix anything that needs fixing.
6. Go to the order page and upload gerbers and pick options as usual. Keep in mind that only green soldermask and 1oz copper is supported for assembly. In ‘SMT Assembly’, click the button to enable assembly. Pick a side to assemble, and confirm.

1. Upload the files generated by the script. Next.
2. You’ll get a list of matched parts found. Check each one, and click “confirm”. You have to confirm every part before you can proceed.

1. Very important: Zoom in on the mockup diagram, and make sure all the polarities and orientations as indicated are correct. Some of them probably won’t be, because KiCad footprints seem to have different canonical orientations.
2. Note down the footprints with incorrect rotations, and the additional rotation required to make them correct (positive is clockwise).
3. Edit ‘cpl_totations_db.csv’ in the same directory as the conversion script to add those footprints. The first column is the footprint pattern to match in regex, and the second column is rotation correction.
4. Run the script again to generate new BOM and CPL files. Go back on the JLC page and upload those new files. Repeat until all orientations are correct, and place the order! Keep in mind that unless you are using very expensive components, the price for 10 boards will be very similar to the price for 5 boards (minimum quantity) because most of the cost is in setup. I would order 10 if there’s any chance that you’ll need more than 5.
5. Please contribute your corrections to the db file so others can benefit. Either do a GitHub pull request if you know how, or just send me a quick message at m@matthewlai.ca. Thanks!

1. Wait for the board to turn up and solder all your thru-hole and other additional components.

The board I’ve decided to test this on is a ESP32-based WiFi 8 channel PWM controller with a USB-UART adapter IC (Silicon Labs CP2104) and a few auxiliary sensor inputs. On a 6x5cm 4-layer board (mostly screw terminals). I probably could have made it 2-layer if I really wanted, but given how cheap JLC’s 4 layer boards are, I decided to use it as an exercise to see how small I can make the board, with nice power and ground planes. I used a QFN USB interface chip (I probably wouldn’t have if I was soldering this by hand) and plenty of 0402 passives. There are about 50 assembled parts in total per board. The only parts they couldn’t assemble are the ESP32 module, and all the connectors. They should all be pretty easy to hand solder and I am happy that I don’t need to order and organise storage for all those different jellybean components.

The whole thing came to $72.17 before shipping. Including 10x 4 layer boards, $27.51 worth of ~500 components (total for 10 boards), and assembly. How amazing is that?

A bare 4 layer board would have costed more than that just a few years ago.

If I really optimised it for cost by squeezing it into 2 layers and soldering it myself, I probably could have gotten it for maybe $30 less. But it would have taken a few more hours of my time at the very least. Is that a worthwhile trade-off? For me, trading $30 for a few hours of my time is a no-brainer.

If you are a hobbyist who still gets pleasure from soldering, maybe the service isn’t useful to you, but I’ve soldered enough TQFP FPGAs by hand in my life that I’m very happy to let someone else do the soldering, so I can focus on more interesting bits. Especially when that someone else is a machine that can solder much better than I can by hand.

Results

8 days from order to delivery to London, UK, using their DHL shipping option ($19.36). This is a 4 layer board, and they say 2 layer boards should be a few days faster. They also have a nifty progress checker on their orders page.

Quality-wise, there’s really nothing I can nitpick. It’s perfect. The QFN and all the 0402s all look amazing, and no reflow solder residue (tiny solder balls) anywhere. There is some extra solder on the ESP32’s unsoldered pads, but that’s typical of HASL process, and those pads were not reflowed. It also looks much worse in the picture than in real life. They are pretty flat in real life, but of course if you are doing BGA you should opt for ENIG finish for better co-planarity (they offer that for about $20 extra).

I am totally blown away and will be using this service a lot more in the future. No more soldering millions of simple components!

Happy making!

Notes:

• Conversion script: https://github.com/matthewlai/JLCKicadTools
• My test board: https://github.com/matthewlai/WiredHut/tree/master/hardware/light_control/light_control

I am currently working on a tensile strength testing rig that will be detailed in a future post, but as part of that project, I need an Arduino shield that can drive a 12V/13A linear actuator. Electrically speaking, linear actuators are just DC motors. However, because I need to be able to drive the motor at constant current, I also need very fast current sensing and switching.

My requirements:

• 13A continuous
• High speed current sensing (about 5 microseconds latency)
• High speed switching (no significant switching losses at 100kHz)

First, a bit of theory. With brushed DC motors, there are two important and very simple equations –

, where is the unloaded speed of the motor, is the motor velocity constant given by the manufacturer, and V is the applied voltage.

, where is the torque produced by the motor, is the motor torque constant given by the manufacturer, and I is the applied current.

These apply to ideal motors, and real motors are quite a bit more complicated, but these equations are good enough for what we are trying to do here. The important thing to pick up is that if we want to run a motor at constant speed (at no load), we apply a constant voltage. If we want to maintain a constant torque, we apply a constant current. This is why we need constant-current drive, to be able to control the force on the material under test.

If you are not familiar with the basics of motor driving or pulse-width modulation (PWM), I recommend checking out my post on that topic first.

As a reminder, here is the basic motor control circuit:

The motor M1 is controlled by N-MOSFET Q1 acting as a switch. R1 is a pull-down resistor to keep the gate turned off when the gate isn’t being driven (microcontroller in reset, during power-up, or if the microcontroller hasn’t been programmed yet). D1 diode is for flyback protection – motor coils are inductive, so when they are switched off suddenly, they will try to continue pushing current through the MOSFET, by generating a very high voltage, and that will often destroy the MOSFET. With D1 across the motor, the motor will drive the current through D1 instead.

Because I need to drive the motor in both directions, I need something a bit more complicated – something called an H bridge.

Here we have 4 control signals. To run the motor in one direction, we activate HighSide1 and LowSide2. To run it in the opposite direction, we activate HighSide2 and LowSide1. Not all control input combinations are valid – if we turn the MOSFETs on the same side on at the same time, they would short the power supply. So we have to make sure we don’t do that in software, and have a fuse in the circuit as a last line of defence in case a bug in the firmware causes us to do this.

Aside: If you studied the H bridge circuit in university, you have probably seen it with P-MOSFETs on the high side, because they are easier to switch in that configuration. With N-MOSFETs on the high side, you need to apply higher than supply voltage to turn the gates on. However, in real life, almost everyone use 4 N-MOSFETs nowadays, because they tend to be more efficient (lower Rds(on)) than P-MOSFETs built with the same technology. The high voltage required to turn the high FETs on is usually supplied by a charge pump, usually integrated into the driver IC.

The last step is to add current monitoring, both so we can do constant-current drive, and also so we can detect when the motor is stalling. There are many ways to do it, but the most common way is to add a shunt resistor (a very small resistor in series with the motor), and measure voltage across that. The voltage is often very small, because having larger voltage here means the resistor will be wasting more power. So we usually also need an amplifier.

This application is so common that they actually make special-purpose resistors and amplifiers for them – current-sense resistors and current-sense amplifiers. I picked , and an INA240 current sense amplifier with a gain of 50. Why these values? Two competing objectives:

1. We want the resistance to be as high as possible to reduce the gain needed on the amplifier, because the amplifier will amplify noise as well.
2. We want the resistance to be as low as possible so we are not wasting a lot of power on the resistor (and even worse – having to heatsink it!)

With , we have:

And

Why 2.275V? Because our Arduino has an analog input range of 0 – 5V, and if we design the circuit to make the mid-point (zero-current point) 2.5V, having a 2.275V range means we are mapping [-13A, 13A] to [0.225V, 4.775V], which is roughly the output range of the amplifier (Datasheet, Page 6, “Swing to Vs power-supply rail” and “Swing to GND”).

Here is what our (simplified) circuit looks like now:

The last piece of the puzzle is to drive the gates from Arduino outputs. We can’t just connect them directly to the gates, because:

1. Arduino only outputs 5V, which is enough for the low FETs, but not the high ones, which require about 18V in our application.
2. Arduino outputs have low current capacity and won’t switch the gates fast enough, which means the FETs will spend more time in the “saturation region” (when they are in the process of getting turned on or off), and FETs dissipate a lot of power in this state.

So we want to use gate driver chips. There are many gate drivers to choose from, but MC33883 is exactly what we need. It can drive the gates quickly, and also generate the 18V (or so) required to drive the top N-MOSFETs.

This is basically the example application circuit given in the datasheet:

The resistors are gate resistors. We put them here because the driver is very powerful, and if we don’t have any resistance here, it will draw huge current spikes at every switch to charge and discharge the MOSFET gates. We slow it down a bit with these resistors to keep our supply rails a bit cleaner. What specific values to use is a bit more complicated – first we have to figure out how fast we need the FET to switch, and then look at the MOSFET’s gate capacitance, and use that to figure out the maximum gate resistance we can put in. If you are interested in how this works, see the end of my tutorial on switching loads (in the PWM section). If you are a beginner and don’t want to worry about this yet, will work in most applications.

The numbered signals go to the corresponding Arduino pins.

That’s it really!

Full schematics

PCB Design

On the PCB design side, this circuit is reasonably straightforward, but there are a few things to be careful with.

• Traces carrying the motor current need to be very wide. 13A is a lot of current for PCB traces. Here is a calculator. In this design I actually used fill zones for these traces, to make them as big as possible. Fill zones are a very good tool for designing high current circuits in small space. The highlighted zones are the high current traces:
• Front:

• Back:

• Another thing to think about is grounding, in particular, the problem of grounds stop being grounds. The motor will be dumping quite a lot of current into the ground through the MOSFETs, and that multiplied by trace resistance means some parts of the ground traces will actually be at a higher voltage! It causes problems if we connect digital ground to the lifted parts of the ground conductor, because all our signalling is ground-referenced, and when different parts of the circuit sees ground at different potentials, they will have trouble talking to each other.
• Illustration (here “Digital Circuit” sees a higher ground due to PCB trace resistance and all the current the motor is dumping through the trace):

• The solution is to have all the different parts of the circuit connect to ground in a star configuration – only connected together at one point, where the ground conductor enters the board. This is how I implemented it on this board:
• Ground for the motors:

• Ground for the rest of the circuit (digital stuff):

• There are a few places where the motor ground and digital ground are very close on the right side, and it would seem like I can save quite a bit of routing by just connecting digital grounds on the right side to the motor ground, but that would be a bad idea. This star configuration gives digital circuitry nice and clean ground to work with. Also notice how the ground for the digital circuitry is split into two branches – one along the top of the PCB, and one along the bottom. They aren’t connected together because that would create a ground loop, where it will act as an antenna to either receive or radiate noise. This probably wouldn’t be a problem in reality in this design, but it’s good practice to keep the star a star.
• Add test points! This is not specific to this project. It’s very easy to add test points during design, and much harder to find places to probe hard-to-reach signals when you need to debug a design that isn’t working. All the 2-pin headers in this design are test points. I have test points on the various supply voltages, input signals to the gate driver, and output of the current sense amplifier.

That’s all folks! In the next post we’ll talk about using an oscilloscope to verify that all the signals look like what we expect.