Browsing posts in: Electronics

EagleDecorations Ornament Creation Instructions

Thank you for buying one of our ornament kits. These are the generic instructions that apply to all of our ornaments; please look at specific instructions for your kits for more details.

Tools & Supplies

You will need the following supplies:

  • A small soldering iron
  • Solder
  • Needle nose pliers
  • Diagonal cutters or other tool to trim leads and wire
  • A power supply for the kit your ordered – either a 5V USB charger or a 12V power supply.

LEDs and Resistors

To keep LEDs from burning up, we will be including resistors that will limit the flow of current through the LEDs and equalize the brightness between different ornaments.

Depending on the color of the LED that we are using the the voltage we are using for the ornament – either 5 volts or 12 volts – we will be connecting chains of 1, 2, or 4 LEDs to a single resistor. The instructions for your kit will tell you how many LEDs to put in the chain for each resistor. If there are multiple colors in your ornament, each color may use a different number of LEDs in the chain.

Creating chains

Here is an example of creating chains of 2 or 4 LEDs, taken from the yellow star ornament:

IMG_7062

Note that the LEDs are placed with the longer lead towards the outside of the ornament. That is the basic pattern we use for all of the ornaments.

IMG_7063IMG_7064

In these pictures, we are making chains of 2 LEDs. In the left picture, the longer lead on the closest LED is bent towards the shorter LED of the next LED. In the second picture, the short LED on the second LED is bent back towards the long lead from the first LED. Connections between LEDs should always be done in this manner.

Here is what it looks like after creating two chains of 2 LEDs:

IMG_7065

A 4 LED chain looks like this, with 4 LEDs connected in a chain.

IMG_7066

A full set of chains

The outline of an ornament will be a series of chains; it will look like this:

IMG_7068

Adding resistors

After the chains are created, we will need to add a resistor for each chain. The resistors are always connected to the inside (shorter) lead at one end of the LED chain:

IMG_7069

When all the resistors are connected, it will look like this:

IMG_7070

Hooking the chains together

The next step is to hook all of the chains together. We will do the insides first. This is done with some of the bare copper wire included in the kit. Start by taking the wire and bending it into a rough approximation of the template, and then put that inside the wire.

We will be connected the currently unconnected end of each resistor to the bare wire.

IMG_7071

As shown in this picture, you may need to reroute the resistor wire a bit to make it easier to connect to the bare wire. Here’s a close up of that:

IMG_7072

Once all the resistor wires are soldered on, trim the resistor wires. Next up are the outer wires. The outer wires run around the perimeter of the LEDs and are soldered to the remaining unconnected LED lead. Make sure the outer wire does not touch any other wires.

It is very useful to clamp the outer wire down as you are routing it around. I use a little alligator clip:

IMG_7074

Here’s what it looks like when finished:

IMG_7076

At this point we would test by applying the appropriate voltage to the inner and outer bare wires.

Adding the power cord

Locate the power cord – either the USB one with the 5V kit or another one if you are building the 12 volt version.

At the bottom of the ornament, you will find two tiny laser-cut holes. The are for the zip-tie that will hold the power cable in place. Pass the zip-tie from back to front and then to the back again, place the power cable in approximately the location you want and lightly secure it with the zip tie. Solder the power cord wires to the two bare wires, verify that it works, and then tighten the zip tie. Cut off the extra.

Success! You have completed the ornament:

IMG_7080

Protecting the wires

The wires only carry low voltage, so there is little shock hazard.

If you want to waterproof the ornament, I have had good luck with 100% clear silicone sealant. Make sure to cover the base all the LEDs and over and under the resistors and all wires. This approach has survived multiple holiday seasons outside in wet and cold weather, but there is no warranty for outside use.


WS2811 Expander Part 6: of MOSFETS and voltage drops…

After I wrote the stress test article, I decided to put a voltmeter across the drain and source of the MOSFET and figure out what the voltage drop was. I hooked up the output to an LED ornament, watched the brightness cycle up and down, and put my probes on the MOSFET.

What I expected was pretty simple. In the sweet spot of the MOSFET I’m using, it claims a Rds – resistance between drain and source – of 10 milliohms. That means I should expect a voltage drop at 5 amperes of:

V = 0.01 * 5 = 0.05 volts

That low voltage drop is one of the reasons to use a power MOSFET; a bipolar transistor would have a voltage drop of about 0.6 volts, and therefore waste more power and get hotter.

The voltage jumped around a little, and settled down at full brightness:

0.8 volts

Okay, that is really unexpected; I played around with different voltages, and I still got 0.8 or 0.9 volts.

My first thought was that the MOSFETs that I got from Ebay might be counterfeit, so I waited for my order of real parts to show up from Arrow, built a new board, and it read:

0.85 volts

This is really confusing, so I asked a question on Reddit’s /r/AskElectronics subreddit.

The first answer I got was that it might be the base diode because I had the MOSFET backwards.

So, I pulled out the datasheet for the MOSFETS and looked at my schematic and board in Kicad. As far as I can tell, everything is wired correctly.

A deeper answer suggested that if I was doing PWM (I had been testing at brightness = 250 because I knew that would be more stressful for the MOSFET than always on), I should test with always on. It also talked about gate capacitance.

<digression>

This is one of those cases where real devices diverge from ideal devices. FET stands for “Field Effect Transistor” – current through the source and drain is controlled by the field on the gate. You establish a field by the flow of current to charge it up to an appropriate voltage.  The amount of current it takes depends on the gate capacitance (described as “Input Capacitance” on the datasheet). For the MOSFET to turn on, you need to flow enough current to establish whatever voltage you want on the gate.

Or, if you think of the gate as a capacitor, it takes a bit of time for it to charge. In my case, the time it takes to charge will be controlled by the pull-up resistance and the capacitance.

Let’s say we are running at 5V, and our MOSFET has 1nF input capacitance (pretty close), and we are charging through a 10K capacitor.

This calculator says that the time constant is 0.00001 seconds, or 10 microseconds.

</digression>

So, I went and changed the animation code to run all the way to full on – luckily my code is running on an ESP8266 and animations can be changed over WiFi – and rechecked the voltage drop.

Would it surprise you if I told you it was 0.8 volts? Probably not at this point…

Perhaps it’s my voltmeter; I have a nice Fluke but how about if I try using my oscilloscope (a Rigol DS1102D I picked up a while back)?

So, I powered it up, hooked it up, and looked at the waveform across the load. I showed the a nice PWM waveform…

But wait a second… I had updated the animation.

My debugging rule is that when things seem unexpected, back out a level and retest the assumptions. Usually one of those is wrong.

I started with my controller code. I suspected the gamma mapping code, so I added some Serial.println() statements and verified that, yes indeed, the colors were getting set to 255. So, that part was fine.

I next suspected the support library I use (the rather excellent NeoPixelBus). I read through a bunch of source but didn’t seem to be any issues. The code all looks fine…

Was the data getting to the WS2811 correctly? So, I fired up the scope again and hooked it to the data line. On full on, the data looks like this:

NewFile0

The WS2811 uses an encoding scheme where a short positive pulse means “0” and a long positive pulse means “1”.

That is a full string of ones; you can’t see all 24 of them, but trust me when I say they are there. You can see this switch back all the way to all zeros as the animation progresses.

So, the software is telling the WS2811 to go to full bright, but it is still turning off for part of the cycle. Here’s the output straight from the WS2811:

NewFile4

That little positive spike is 29.4 microseconds, which is about 5% of the 536 microsecond cycle time, so full bright is only 95% bright.

The cursors on the capture show the start of two sequential PWM cycles, and the scope nicely tells me that it’s updating at 1.87 KHz. Which is another weirdity, since every source I’ve seen suggests that WS2811s update at 400Hz.

At this point I’m beginning to wonder if I have a WS2811 clone. I thought it might be the same IC used in the SK6812 ICs, but the claim is that they have a PWM frequency of 1.1KHz which is less than I am seeing.

So, it’s off in search of some real WS2811s. It is really easy to buy cheap ICs made in China but is surprisingly hard to find an authorized source. There are lots of sources on aliexpress, some looking pretty shady. Octopart found me a 10-pack from Adafruit for $4.95. I finally found lcsc.com, which specializes in this sort of thing, and ordered some. They look to be WS2811S chips, but I can’t find any information on what the “S” means. More on that when they show up.

Back to voltage drop…

Since the WS2811 wouldn’t go into “full on” mode, I needed a test setup to do my testing. Here’s what I came up with:

image

In the right middle is the MOSFET, with clips connected to the lead and the body. In the picture, it is running only the LED Star, which pulls 145mA of current.

One of the fun things about MOSFETS is the gate holds onto the charge, so if you just touch the gate to 12v, it turns on and stays on. Touch it to ground, and it turns off, and stays off. I measured the voltage drop across the MOSFET.

I next decided to hook up my test load. I started with a single 50 watt bulb, a 4 amp load. I carefully hooked it up in parallel with the led star, and…

There was a loud “crack” and the led star went out. No magic smoke, but the MOSFET was toast. The gate was floating, and there wasn’t enough charge there to put it firmly into full conduction, so it was in the linear zone and quickly overheated, melting the plastic on one of my clamps. So… replace the MOSFET, make sure the gate is attached to positive, and try again. That worked, and the MOSFET was only mildly warm. Let’s try two bulbs for an 8 amp load. That worked, *but* there is no heatsink and it got hot pretty fast, so I unplugged it before it got too hot.

I collected some data and figured out that the Rds was about 90 milliohms, which is a lot higher than the 10 milliohms I expected. That was a mystery for about 8 hours, until I was writing this up and realized that I was measuring the voltage drop at the ends of the leads connected to the MOSFET. The thin leads.

So, I went back and measured right at the MOSFET, and got a Rds of 7 milliohms, a bit better than the 10 milliohms that was spec’d. So, yay!

Faster switching

Returning to our somewhat slow switching, here is what I saw:

NewFile2NewFile3

The negative transition is when the transistor turns on; notice how effortlessly and quickly it pulls the gate voltage down. And when the transistor turns off, note how long it takes it for the gate voltage to charge back up. It’s roughly 10% of the overall cycle time.

Which is a bit embarrassing; I chose the 10K value as a typical pullup value, not thinking about the fact that this was happening on every PWM cycle. It can only supply about 1 mA of current.

The most obvious thing to try is to replacing it with a 1K resistor. That will result in 10mA of current and should switch roughly 10 times faster. Can the transistor handle it? The datasheet says that the 2N3904 can handle up to 200 mA continuous, so that will be fine. Is the base resistor okay? Well, transistor has a DC current gain of at least 50, so that means we need a base current of 10mA / 50, or 0.2mA. The 5V from the WS2811 will push about 4 MA through the 1K base resistor, so that’s way more than enough. It would probably be fine with a 10K base resistor, actually.

I took one of the boards and replaced one of the 10K resistors with a 1K resistor and then looked at the gate drive:

NewFile5

In case it’s not obvious, the top version is with the 1K resistor and the bottom one is with the 10K resistor. More than good enough for my application.


WS2811 expander part 5: 12V stress test…

One of the points of the expander is to be able to drive bigger loads than the 18mA that the WS2811 gives you directly. Much bigger loads.

To do that, I needed something that would stress the system, and I needed to verify that the design worked with 12V.

First off, I needed to cut a new stencil uses the paste layer:

IMG_9501

That’s a bit nicer than the first one; there is adequate spacing between the pads this time.

Aligned it on the board, applied paste & components, and reflowed it. Here’s the result, still warm from the oven:

IMG_9502

All the components self-aligned nicely, no bridges, no missing wires. Perfect.

The only thing I need to do is get rid of the center pad for the MOSFETs, since they don’t actually have a center pin.

How to test it?

Well, I dug through my boxes and found a 5 meter length of 12V LED strip. It says that will be 25 watts. I hooked it up and verified that all 3 output channels are working. It’s running an animation that ramps from 0 to 255 over 2 seconds, holds for 2 seconds, and ramps down for 2 seconds. I chose that because the quick switching is the hardest for the MOSFET to deal with from a heat perspective.

But 2 amps isn’t quite enough. I dug out a 12V power supply that claims it can do 6 amps and hooked it up to one output channel:

IMG_9504

That’s the NodeMCU board in the upper right, powered by LED, the data and ground running to the board, and then some decently-hefty wires running to the board.

More load, more load, more load. I want something that soaks up the 12V. Incandescent car bulbs are nice but I don’t have any handy. But I do have an extra heated bed for my 3d printer; it’s a nice 6” x 6” pc board. Hooked that up in parallel with the lights:

IMG_9505

Ignore the breadboard…

This worked just fine. The board heated up to about 170 degrees, the lights worked fine, and the MOSFET on the driving board just *barely* heats up. My measurements show that it’s switching about 5 amps of current.

The only one that’s not happy is my cheap power supply, which is putting out a nice 10Khz (ish) whine when under load.

I switched over to run it on all the time to see how that affected things. After 10 minutes, the board is up to about 110 degrees, the printer bed is up to 240 degrees, and the 12V power supply is 125 degrees.

I think I’m going to rate it at 6 amps total; that gives a lot of margin, and frankly 70 watts is quite a lot of power for this application.


WS2811 expander part 4: Boards and Parts!

After a bit of waiting, the boards showed up from OSHPark. they looked fine as far as I could tell.

I had all the other parts to do a board, but I needed a paste stencil. I went into pcbnew, chose File->Export, and then chose to export the F.Mask (ie solder mask) layer to a SVG. I cleaned it up a bit to remove non-pad elements, went out to the laser cutter and cut a stencil out of 4 mil mylar:

IMG_9495

Everything looked pretty good; there was good alignment between the board and the stencil. The spacing between the pads looked a little tight, but it’s a fairly fine pitched board, so it was mostly what I expected.

I carefully aligned the stencil and taped it on, got the solder paste out of the fridge, and applied it. Pulled up the stencil and it looked crappy, scraped it off, did it again, and got something that looked serviceable though there was more paste than I expected. Hmm.

Got out the components:

  • 1 WS2811
  • 1 33 ohm resistor
  • 1 2.7k ohm resistor
  • 6 10k ohm resistors
  • 3 1k ohm resistors
  • 3 NPN transistors
  • 3 MOSFETS
  • 1 100nF capacitor

and it took about 5 minutes to do the placement. Here’s the result:

IMG_9496

I didn’t look at the picture at the time, but that’s a *lot* of solder paste.

Into my reflow oven (Controleo 3 driving a B&D toaster oven), let it cycle, seemed fine, here’s the board:

IMG_9499

Not my best work. Frankly, it’s a mess; there are obvious places where there is no solder, and obvious pins that are bridged together. I spent about 15 minutes with my VOM testing for continuity and there were 3 solder bridges and 7 unconnected section.

Something clearly went wrong. And I went back to PCBNew and it was *really* obvious.

The layer you should choose for your stencil is F.Paste, not F.Mask. Here are the two next to each other (Mask left, Paste right):

imageimage

The Mask layer sizes are positively giant compared to the paste ones. So, what happens if you use the Mask layer is that you have:

  • A *lot* more paste on the board, especially the small pads which must have double the amount
  • Solder paste with much reduced clearances.

What that means in reality is that when you put the components on, it squishes the solder paste together and connects pads that shouldn’t be connect. And then when you head it up, you either get bridges or one of the pads wins and sucks all the paste away from the other pad (how it wins isn’t clear, but it is clear that the huge MOSFET pads pulled all of the paste from the transistors next door).

This makes me feel stupid, but it is actually quite good news; it means that the design is fine and I just need to remake a stencil with the correct layer.

Anyway, after a lot more rework than I had expected, I ended up with this:

IMG_9500

It’s still an ugly board, but does it work?

Well, I hooked up 5V, GND, and data in to one of my test rigs and a LED to the LED outputs.

And it works; the LED is on when I expect it to be on and off when I expect it to be off. All three outputs are fine.

The next test will be some testing to see how it fares with switching high current. And I’ll probably want to make another one using the correct stencil and hook it up for 12V operation to verify that.





WS2811 expander part 3: PCB Revisions again…

More revisions.

I posted the design to /r/PrintedCircuitBoard, and of the comments said:

“Do you need pullups on the outputs of WS2811?”

And of course, I was confident the answer was “no”. For about 5 seconds. And then I measured the WS2811 I have in my breadboard; it gave a nice solid sink when it was on, and when it was off, just a fraction of a volt. Clearly not up to sourcing current to the NPN transistor.

The most likely explanation is that it’s an open collector output:

The collector on the output transistor is just left hanging – it’s only collected to the external pin. The voltage on an open collector can float up above the internal voltage of the IC as long as you don’t exceed the maximum voltage of the transistor

Open collectors are really useful if you want to have a bus architecture with multiple components able to pull the bus low, or if you aren’t sure what voltage of the output is going to be. Since the WS2811 can be used to drive LEDs tied to either 5V or 12V, it makes perfect sense. And it is confirmed by the internets.

Which means that the circuit needs to get a tiny bit more complicated:

image

Another pullup resistor is added to the mix. Really not a problem from the cost and assembly perspective as the design goes from 9 resistors to 12 resistors.

But, can I fit it in the current board layout without making it bigger?

I should probably add a parenthetical note here that says it’s often easier to go with a bigger layout, and in fact if you are going to hand solder a board, you *should* go with a bigger layout. Though I’m not sure how practical it is to solder the MOSFETS by hand since the base pad is so big…

Anyway, here’s what the board looked like before:

I need to put a resistor between each of the traces that head from the WS2811 over to the transistors. Hmm.

I initially just tried to fit them in there, and with a big of rerouting, I was able to make it fit. Technically.

Then I decided that it would be a lot easier if I moved the vertical ground trace underneath the transistors and used that to provide the ground connection to the transistors. That meant I could move the VCC vias around more easily, and could do the following:

image

The fit in reasonably well.

I *think* it’s ready to order the first version of the board, but there’s one more step. I now have on hand the WS2811 ICs and both kinds of transistors. So, I printed out a design with the copper layers shown, and did a test to see if the components really fit on the board.

image

That shows the WS2811 on the left, the MOSFET on the right, one of the NPN transistors and then a tiny 0805 10K resistor at the top. Everything looks like it will fit fine.

I ordered 3 boards for $7.10 from Oshpark, which is my usual supplier for prototype boards if they are small.


WS2811 expander

I’m starting a new decorations project that will involve a fair number of standard LEDs, but not addressable ones. I have a few different use scenarios:

  1. Plug into a standard USB power supply.
  2. Power directly with 120 VAC.
  3. Power either with 5V or 12V and have an easily way to control brightness…

The first two are just wiring, but the third needs something more. My target market is quite used to using WS2812 addressable LEDs, so I’m going to build something that works in that environment.

Quick requirements list:

  1. Runs on 5V or 12V.
  2. Uses WS2812 protocol.
  3. Can drive significant loads (at least 10 amps).
  4. Small and cheap

The second requirement is pretty simple; you can buy the WS2811, which works exactly the same way as the WS2812 lights but is in a separate package. And it very conveniently has a little internal power supply that can use 5V or 12V by changing the value of one resistor. Here’s a typical 5V circuit:

image

Looks very nice, and almost does what I want, except that it’s designed to only sink 18.5 mA, which is quite a bit less than my 10 amp goal. I don’t strictly have a use for 10 amps right now, but I will likely need at least 1 amp for some uses.

So, I’m going to lean on the IRLR7821PbF MOSFET that I used in my backyard controller, which it looks like I can get for about $0.14 each. It’s pretty easy to use:

image

I will just drive the gate of the MOSFET with the output of the WS2811, and when the MOSFET turns on, it will pull the LED1 line low, turning on the LED.

Except… the WS2811 outputs are active low, and the MOSFET in this arrangement is active high. So

image

We add an NPN transistor. If the input is low, the transistor is off and the gate on the MOSFET is pulled high by the 10K resistor. If the input is high, the transistor is on, the gate is pulled low, and the MOSFET is off.

That will be duplicated for all three channels, and we end up with the following:

image

R9 and R10 are really just empty holes; you bridge R9 with wire if you want to use 5V and R10 if you want to use 12V.

I unfortunately generally forget to take snapshots during PCB design, so here’s the V1 state:

image

The MOSFETs have lots of 4s on them – I don’t know why – and to the left are the bipolar transistors and the resistors required for that part of the circuit.

The power input holes and the LED holes are designed to use Molex KK 396 headers and connectors so you can either use those or hand wire.

The lower left shows the jumper locations to set voltage.

All resistors are 0603 sized; that makes them compact but still relatively easy to populate.

The only weirdness are the three through-holes next to the LED terminals. I need to tie that backside ground trace to the frontside MOSFET terminal, but I was having trouble fitting enough vias to carry the current. Instead, I just used the through holes, which will be filled with solder and therefore be able to carry plenty of current.

The board is about 40mm x 28mm in size. I might jump up to 0805 resistors to make it a little easier to fabricate.

Before I send it off to be fabricated, I need to have the transistors in hand so I can verify the layout works.






Backyard controller design #4 – Software

The controller software lives here on github. My current software development environment is Visual Studio Code with Platform IO installed on top of it. It’s quite a bit better than the Arduino IDE for my usage patterns.

I’ve done my best to build a flexible and well-abstracted design. With the exception of main.cpp, all of the C++ classes are written in the include (.h) files so that I don’t have to deal with multiple files per class.

Here are the classes and a brief description of what they do:

  • Action – takes in a textual description of an action (on, off, toggle, plus some dim levels) and converts it to a numeric value. This is a nicer pattern to use than an enum as the parsing code can live here.
  • Device – an abstraction for a device that I want to be able to control. It has a text name, a group name, an output pin, and a timeout (in 10 mS units). If you pass it a name and an action, if will implement that action if the name matches either the text name or the group name of the device.
  • HardWiredController – the physical controller (not yet built) has a group of switches connected via resistors to the input line, giving a varying voltage based on which switch is pressed. This code uses the ADC in the ESP to get the current value, figures out what button was pushed, and performs the appropriate command.
  • Main.cpp – the main setup and loop code. Mostly just delegates out to other classes.
  • MainPage.h – the text of the web interface page for the controller
  • Manager.h – the manager for all the devices. It creates an array of devices and then handles dispatching commands to them, getting status strings, handling timeouts, etc.
  • OnIfAnyDevice.h – the 12V power supply needs to be turned on if any of the lights are on. This class looks at the state of the devices passed in through the constructor and turns itself on if any of them are on.
  • StairSensing.h – The program needs to turn on the house lights if the stair lights are turned on. This code tracks whether the stair lights have been turned on and switches the house lights on and off as necessary.
  • WebServer.h – The code that handles requests for the UI page and url action commands.

The main loop runs with a 10mS delay so that every time through the loop is roughly that long; that is needed to implement the timeouts in the device class. I could have done this in a more sophisticated manner but what I did is clear and good enough for the requirement.

The Manager and Device classes warrant a bit more discussion. They are use a software pattern called “Chain of Responsibility”; there are basically 5 devices that all look alike, and the manager just passes the action through to all of them and the device that the action belongs to deals with it.

This vastly simplifies the manager class – otherwise it would have to check every string and figure out which device to pass it to – and makes it really easy to implement group devices; the “lights” group refers to all light devices. It also makes it easier to implement the OnIfAnyDevice class, which otherwise would have required special case code.


Backyard controller design #3–Board & construction

In our last installment, we were trying to decide whether to hand-wire the controller or to go with the PC board. The PC board won out handily since it only cost $13.30 for the standard 3 boards from OSHPark.

Here’s a picture of the board with populated with the 3 MOSFETs and 5 resistors. I did the solder paste application by hand since I only need to do one of these. Standard solder-paste since the MOSFETS may switch up to around 8 amps and therefore may get a bit warm.

image

And here’s a picture after the reflow. Reflow done in my Controleo 3 toaster oven reflow-er. Looks just fine.

image

One little comment: One problem I had during layout was how to connect the top pin of the MOSFETS to ground in a way that could flow enough current from the front to the back. My first design started with a number of vias, but I didn’t like it. Then I realize I had an easier solution; I just use a single through-hold pad and hand filled it with solder. It will carry far more current than I need.

Build

In my original concept all of this was going to fit inside of a double-gang electrical outlet box, but I realized that a) I’d rather mix as little low voltage and line voltage as possible and b) the box I used was only half-depth, so no room. Which argued to use a box and mount it to the house. Here’s the one I chose:

image

It’s a good size and has mounting bars. I don’t really need the gasket because I’ll be cutting holes for the wires. $11.60.

The next order of business was to figure out how to connect the big 12-gauge lighting wire to small connections on the board. I am lucky enough to have a good local Electronics store 15 minutes from my house (if you are in the Seattle area, Vetco is worth a trip), and that yielded a couple of terminal strips:

I think I bought two for $4.99 each, plus I bought some 18 gauge wire to go from the board to the strip (the big holes on the board can only support 18 gauge. Which led to this:

image

Those are all of the connections that take big wire, and the terminal strip color-coded with Sharpies.

Yes, I know I messed up the sequence; the 12V in at the lower right portion of the board really wanted to be there for each connection to the three 12V outputs. And it turns out that the wemos nodemcu layout I used was upside down, so the ESP-12 is hiding underneath the module rather than on top of it. There are female headers soldered to the board and male headers soldered to the nodemcu board. This allows me to easily remove it for reprogramming. Which was already required a time or two.

I used the same technique for the remaining controls I needed but they don’t map 1:1 to the board.

image

Here’s a few steps at once. I found an MDF cutoff and used that as the back of the board, and the screws that mount it also mount the terminal strips.

On the upper right terminal strip we have 120VAC coming into the box; that connects to a 5V power supply. There is a small 2AMP SSR that I had lying around that will switch on the 200  watt 12V power supply when it is needed. The “Pump on” output will connect to a similar SSR in the remote electrical box.

I did a full test of all the features, and they all worked. Well, except for the switching for the 12V power supply, which was broken by a refactoring I did in the software.

Umbrella lights

We have a shade umbrella with some chair under it, and one of the requirements was to have some light underneath it. I didn’t find any premade ones that I liked, so I bought 5 meters of 12V led strip and made my own. I made 8 strips that were 16” in length, attached wire, shrinkwrapped them, and then hooked them all together to a single supply. I only took one picture during construction:

image

But I did get this picture of them in operation:

image

Box installation

The box got installed on the wall and the various wires were hooked up.  This is under my covered kitchen deck so there is no real chance of any water getting in.

IMG_9330

The AC comes in from the far right; that is a 15’ extension cord that plugs into a GFI with an in-use cover; directly under that is the 12 volt 16.5 amp power supply which then feeds back into the 12V input for the board. The red/white wire carries a 5V signal to the SSR in the electrical box that controls the fountain. The three main loads are hooked in along the bottom.

There are two things missing in this picture; the 12V line that used to run the stair lights is not hooked in, and the stair lights are not connected into one of the existing lines. It turns out the transformer for the stair lights does not put out 12V with no load; it puts out 17.3V. I did a conservative design on the board that would support 15V without damaging the ESP, but 17.3V was too much. I therefore built a small in-line voltage divider and used that to connect the stair lights in.

As of now, everything works fine delta one bug that I am chasing down.

I’ll write up a post about the software next.








Backyard controller design #2–schematic and board layout

My original plan for the controller was to do all the wiring by hand on a perfboard (“old school”); it’s not that complicated and I wouldn’t need to wait for a board. But I decided to do a pcb board to see how much it would cost and because I wanted an excuse to try out Kicad 5.0.

I started with the schematic:

image

We have the Wemos D1 mini (clone, actually) in the middle, with 5 outputs (PUMP, 12VPOWER, HOUSE, BED, AND UMBRELLA), and two inputs (STAIR_SENSE and controller). If you haven’t seen labels used in a schematic before, every pin with the same name is logically connected though there is no wire drawn between them.

On the right we have three drivers for the landscape lights using the NPN transisitor/MOSFET circuit I discussed in the last post. All of those outputs connect to the 6-connector header (screw terminal) strip.

On the upper right, the Wired_Controller1 header will be for a (possible) hard-wired controller for the lights and pump. It’s connected into the analog input of the ESP. In the actual handheld controller there will be four switches hooked across a voltage divider so that the switches will give 1V, 0.75V, 0.50V, or 0.25V when pressed. The ESP code will figure out which switch was pressed and therefore which action to take.

In the middle is the AC_Switching1 header. It contains the two outputs to control the remote solid-state relays for the pump and 12V power supply. It also contains the 5V and ground from the 5V power supply that will run the ESP.

On the left we have the parts for the stair light sensor. We have a voltage divider that will convert from the 12 V that will come in to a value that the ESP can tolerate. There was a bit of calculation there. The valid ESP8266 input voltages range from 2.5V (for the lowest guaranteed high value) to 3.6V (the maximum input without damage). We want to choose the voltage divider ratio to work well within that range.

My first choice was to use 330K for the upper resistor and 110K for the lower one; that would give a 4:1 ratio. That would put the lowest guaranteed high value at 2.5*4 = 10V, and the highest tolerable value at 3.6*4=14.4V. I decided I wanted a bit more range on the high side, so I opted from 330K and 100K resistors, giving a 4.3:1 ratio, and a voltage range of 10.75V to 15.5V. I considered overvoltage protection, but given the ampacity of the supply a simple zener likely wouldn’t be enough and I would need an SCR crowbar to handle overvoltage. I decided to skip it in this version as the power supply is a regulated one.

That’s all for the schematic; not really that sophisticated. Oh, the NPNs are really 2N2222; I chose the 2N2219 because it already existed.

image

Here’s the board layout. It’s a weird mix of through-hole and SMD components as I already had both the MOSFETS and the NPN transistors. I started with the header for the landscape lights because they will be pulling some hefty current; that meant I wanted to keep the traces short, and it also meant that I wanted to put the 12V in nearby in the upper right. The controlled where the MOSFETS ended up, which controlled where the NPN transistors and their resistors ended up. I reordered the output pins on the header so that they matched the order of the output pins on the ESP module; I could have remapped the pins as well but this was a bit simpler. The AC switching header also got re-ordered to make the connections simpler. And then I tightened things up a bit to minimize the size of the board. At that point, it was about $20 to do a board from oshpark, which was pretty much the cheapest I could find.

That’s relatively cheap, but I’m not excited about having to wait for it to make it back to me. The footprints for the screw terminals is not based on a header that I have; I bought some terminal strips before I decided to do a board design, but I need to buy some better ones for this sort of design. I need to get real terminals so I can get real dimensions, and I might see what I can do with all SMD devices; smaller terminals and transistors could cut the size of the board by 25%.

Two more things to mention. You’ll notice that there is not a copper pour for the ground. It’s probably not required for a board operating at these speeds, and I would have to be careful around the ESP8266 antenna because having copper underneath it would mess it up.

I did another layout with through-hole resistors in case I wanted to hand build it:

image

Back to the problem in hand… If I was willing to wait for a PCB to show up, I could wait for some new MOSFETS and transistors, and that would certainly make things smaller. So, I went MOSFET hunting, and I found the IRLR7821PbF, available in a TO-252AA package at $6 for 5 MOSFETS. Sound good.

I pulled up the datasheet and started reading. It’s pretty similar to the IRLB8721 that I had currently specified, but on Page 2 I found the output characteristics graph:

image

Looks like the one we saw in the last post, right? Except this this one starts at 2.5V and 2.7V curves. Looking at the 3.0V curve – to be conservative – and we see that with 10V drain to source, we can get a little more than 10 amps of current at a junction temperature of 25 degrees. At 3.3 volts, it’s closer to 12 amps.

What that means is that we can drive this MOSFET directly from the ESP8266. We can lose the NPN transistors to drive the MOSFETs plus one of the resistors.

So, off to do a new design with this MOSFET. I decided that I’m going to mount the board, run wires from the board to some terminal strips that I have, and then hook the real wires to those terminal strips. That will make it easier to hook up and I can make the board smaller so that it will be cheaper.

After a lot of iteration, here’s what I end up with:

image

It’s about 30% smaller than the original board; part of that is done by letting the ESP board overhang the end of this board, but they will both be in an enclosure (3D printed, I think), so there’s no harm in that. All of the heavy current stuff is contained on the right side of the board.

I first head to OSHPark, which tells me the board is 48mm x 37mm. That’s less than half the size of a credit card, so, tiny. They will make me 3 boards for $13.30, and oshpark does really nice boards, with an ENIG finish, but they take a couple of weeks to show up. I head next to pcbshopper.com and find nobody cheaper, except allpcb.com. I used them for the boards in my dodecahedron and they’ve done good work, and I can get 5 boards in 5 days for $10, shipping included. They must be blackmailing DHL to be able to ship so cheaply.

I’m trending towards OSHPark since I need to order the new MOSFETs in anyway.


Backyard controller design

I’ve done a lot more work on the backyard controller design and things have firmed up.

Here’s what it looks like.

First, I don’t think the 100 watt power supply I bought is going to cut it; I have 36 watts on the ground and 40 watts on the house, and we’ve added tree accent lighting, fountain accent lighting, and I think I’m going to include some existing stair lighting on this. Oh, and some umbrella lighting. That would put me close or slightly over 100 watts, and that doesn’t leave any margin for losses in the wiring or a power supply that doesn’t quite do what I think it’s going to do.

The project is going to be split into two modules.

The first will live in the duplex outlet and will consist of the SSRs to drive the pump and the power supply and a 5V power supply for the NodeMcu. I have some nice thin 2 amp SSRs that will do nicely for those two loads and I’ve verified that they work fine on 3 volts (they worked okay on 2 volts in my tests), and my current plan is to hot glue them to the back of a split duplex outlet. One outlet will be used to plug the 12V power supply into, and the other will be back wired to connect to wiring that goes to the outlet next to the water feature. I *might* go hunting for some beefier SSRS, but the good ones are unfortunately expensive and the cheap ones have a bad reputation.  So, we’ll see. The ones I have are fine for those applications but if somebody plugs something beefier things will not work well.

The 5V power supply will be just enough to run the ESP; an amp will be fine. And yes, I’m going to break code and mix high and low voltage in the same box, but I will do my best to do it sanely.

From that box I’ll run some 4-conductor cable out. It will have:

  • +5V
  • GND
  • PUMP ON
  • 12V ON

That cable will run to the second box mounted up underneath the deck. It has the following inputs:

  • 12V power (from the power supply)
  • 12V power (from the existing stair lights)
  • +5V / GND

And the following outputs:

  • 12V stair lights
  • 12V bed lights
  • 12V house lights
  • PUMP ON
  • 12V ON

Maybe I’ll add in the under-umbrella lights as a separate circuit; the extra components are cheap and it would be nice to have separate control there.

My current stair lights are controlled by a switch in the garage and a power supply there. I originally thought I’d use a 12V relay to either power them from the garage or this controller, but it’s easier to just sense the 12V in the new controller and power all of them from the new power supply.

The MOSFETS I have are IRLB8721PbF, which are reputed to be decent for logic-level switching… Let’s take a look at the data sheet:

image

What I’m trying to figure out is what sort of current I can expect if I drive them from the ESP8266 pins. My drain to source voltage is 12 volts, so I’m looking at the right side of the curve, and I’ll pick the 3.0 V curve to be conservative. And that shows me that I can get around 10 Amps, which would be 120 watts. With 200 watts planned, I’d only pull 100 watts or so, so it looks like I’m close but okay.

But… Take a look carefully at that graph. See where it says “Tj = 175 C”. Yeah, that’s hot, and it’s the absolute maximum temperature, which means I’d really need some heatsinking or other cooling. The whole point of a nice power MOSFET is that they have low R(DS) resistances and therefore don’t get very hot. Which is not true if you are only driving it with 3V. This is the “if you’re stupid” graph.

There’s another graph in the datasheet:

image

Notice this one says that it has a junction temperature of 25 degrees centigrade. Which isn’t even body temperature. But, to get that from a 3 volt drive, I can only pull 3 amps.

What that really means is that I could easily build a test circuit and have it work great with my test loads of 30 watts or so, and then install it and hook it up to a 100 watt load and it will melt. Which would be bad.

The graph gives a really simple solution; instead of driving it with 3 volts, I need to drive it with something high. Like – I don’t know – maybe the 12 volts that I already have in the circuit. The graph only goes to 10 but if it went to 12 (insert Spinal Tap reference here), we’d expect that it’s pretty much the same. And it shows that we could do upwards of 100 amps from this device in that situation.

We can’t; the maximum continuous is 62 amps, but we can easily pull the 10 amps that we need. And the datasheet also tells us that at 10V(GS), the R(DS) is 8.7 milliohms. So, at a 10 amp current, that means the voltage across the MOSFET will be 0.087 volts, and it will dissipate 0.87 watts. A bipolar transistor here would drop 0.6 volts and dissipate 6 watts, which you would definitely need a good heatsink for.

MOSFETS do see increases in R(DS) as they get warmer. I am *probably* okay, but I’ll also probably put a small heatsink on the MOSFETS anyway and do a little testing overnight to see how they are pushing that much current. Or I could do the thermal calculations to see how much junction temperature rise I can expect.

Or… I might get lazy, and run two of them in parallel. Another nice thing that you can do with MOSFETS that is problematic with bipolar transistors. Bipolars have positive thermal coefficient, so if one gets hotter it pulls more current and things rapidly go downhill. MOSFETs does the offset, so you can generally put them in parallel with no problems.

So, how do we switch it with 12V? There are numerous MOSFET gate drivers out there that are designed not only to use a higher voltage but push enough current to be able to switch quickly; MOSFETS do not technically draw current but they do have gate capacitance so you need to pull some current to get them to switch quickly. That’s really important if you are building something like a switching power supply that you are switching at a relatively high frequency, but for my application, all I need is on and off and it doesn’t have to switch particularly quickly.

So, I’m going to go old school and use a small signal bipolar transistor to switch the gate.

image

The schematic comes from here. It’s really simple; when the logic input is low, the transistor won’t be conducting and the pull-up resistor will pull the gate high, turning on the MOSFET. Turn the transistor on by flipping the logic input high, it pulls the gate to ground (well, to 0.6 volts, which is close enough), and the MOSFET will turn off. It does invert the signal, which is a bit inconvenient but not really problematic in this case, as the 12V is only there is the power supply is turned on.

Pretty much any NPN transistor will do; I have some metal cased 2n2222s in my box, so that’s what I will use.

The only remaining part of the hardware is the sensing circuit for the 12V coming from the current stair light power supply. That’s pretty simple; take the 12 volts in, run it through a simple voltage divider, and I’ll get 3 volts to feed to the ESP.

All this is going to get hand-wired on a breadboard; there’s no reason to do a PC board for this application. I think the connections will all be screw-terminal barrier strips as they work well with the beefy 12 gauge wire for the low voltage lights.

I’m also going to build a small remote that you can use inside so you don’t need your phone to do the switching.

Software

The software will be based on the ESP8266WebServer class, with a simple method to query the current state and separate methods to do the switching. I’ll do turn on, turn off, and toggle methods to provide some flexibility.

I recently switched to VS Code and Platform IO; it took some futzing to get it working, but the experience is so much better than the arduino IDE, and it knows how to create an ESP project that works out of the box. I have the bare-bones http server running for this; I don’t expect the full code is more than a day’s work if that. Oh, and I’ll do a web-page interface as long as I’m doing it.

I haven’t done anything on implementing the advanced functions based on sunset times etc., though I will probably implement auto-off for both the fountain and the lights.


Pages:123456