Friday, January 5, 2018

PROJECT: Slow Motion Frame

This/last year (2017/2018) I decided to make a slow motion frame to celebrate our Anniversary/Xmas/New Year/Valentines/Birthday... lots of birds with one stone ;^)

Here & here is the tutorial I followed. How the frame works is that the electromagnet causes the flower (or what ever you attach) to vibrate at a certain base frequency (say 79.8Hz), if you then strobe the LED's at say ±0.1Hz to 5Hz to the base frequency you will get an interesting optical illusion, the flower will seem to be moving in slow motion.

And here is a video showcasing it working, as well as some progress photos of the build:


Saturday, September 23, 2017

PROJECT: Portable Solar USB Charger

With the wedding world tour coming up and after seeing THIS post by CodeSamurai I was inspired to make a solar USB charger. The countries we planned to go to were about to hit summer so the idea of being able to charge your phone/camera with the power of sunlight sounded pretty neato.

Here is a link to project files (Notes, Altium, SOLIDWORKS, LTspice...)

Project Criteria

I had built up enough experience with LTspice at work so decided to play around with some of the more efficient (but expensive) DC-DC converters out there. My criteria for a winning IC were as follows:
  • First DC-DC converter (Solar) must have some sort of maximum power point tracking.
  • First DC-DC converter must have 1.0V < Vin < 6.0V, this was a limit of the solar cell I wanted to use.
  • First DC-DC converter must have Iin > 0.50A, again limited by the solar cell.
  • First DC-DC converter must have η > 90%, don’t forget this is load dependant.
  • Second DC-DC converter (USB) must have 0.5V < Vin < 6.0V, initially I wanted to operate from a 1S2P NiMH battery.
  • Second DC-DC converter must have Iout > 0.50A, as I wanted something that could do rapid charging.
  • Second DC-DC converter must have η > 90%, again don’t forget this is load dependant.

To save you some time here is a table of all the IC’s I had a look at for the first and second DC-DC converters, the two IC’s I went with are highlighted in green:
From a performance perspective I wanted the final product to meet a couple of other requirements:
  • I wanted the charger to be rugged in terms of components used, if it could still work after 10 years I would be satisfied. So for rechargeable batteries I decided to go with NiCd’s as this chemistry has had a long time to mature and so has the best charge/discharge curves compared to NiMH & Lithium (through the worst energy density).
  • I wanted the overall efficiency to be as high as possible (95%), so I went over-kill on components by using: super low resistance inductors & polymer electrolytic capacitors.

Characterisation – Solar Cell  

Next up I scavenged eBay for a solar cell that was: roughly 110mm x 70mm, and had the highest advertised peak power output. After receiving the solar cell, I did some rough tests to figure out what the actual peak power output was and where it hanged around in terms of Vout & Iout.

For the characterisation I used the very precise and accurate sun as my light source (on a hot summers day with minimal overcast of course), so in all honesty the graph that follows is more of a rough estimate which was good enough for me at this stage. As it turned out the peak power point was ~0.61W and hung around 4.3V @ 0.14A.

Characterisation – Battery Pack    

To characterise the NiCd pack (2S1P) I charged & discharged it several times at 1A. While doing this I also recorded the total accumulated charge (mAh) and pack voltage (V) versus time, and hence got the following curves.
Knowing this I was then able to approximate the battery capacity at a given pack voltage, which I should mention is only true when the battery has a 1A load. This information is useful if you want to get a rough value for the State of Charge (SoC), which I attempt to do with my circuit.


With the important components chosen the next step was to simulate the circuit using LTspice, and as it turned out running a few simulations brought up some key findings:
  • My initial design was based around charging two NiCd’s in parallel (1S2P) which meant both IC’s had to work from 1.2V (nominal). It turns out that working with such a small input/output voltage really hampers the efficiency, as rearranging the batteries from 1S2P (1.2V) to 2S1P (2.4V) improves peak efficiency of the LTC3130 (solar) from 45.2% to 72.5%, while for the LTC3539 (USB) it goes up from 86.1% to 95.0%.
  • With the LTC3539 (USB) you could improve the peak efficiency from 92.9% to 95.0% by placing two IC’s in parallel. Plus, having two in parallel allows the maximum output current to double from ~0.7A to ~1.4A.

Circuit Design - Altium

Now I was finally ready to draw the schematic and layout the PCB, for this I used Altium. Here is a breakdown of the circuit below:
  • The first stage is based on the LTC3130 (solar) energy harvesting IC. Basically this is a DC-DC converter which takes the energy collected by the solar cell and converts it to charge the batteries. It does this by stepping down 4.3V to 3.1V (controlled by R8, R17, and R18) and charging the NiCd batteries to 1.55V per cell. 
  • The nifty thing about this IC is that it can do crude maximum power point tracking (MPPT), crude as it limits the inductor current such that the input voltage hangs around 4.3V (controlled by R1 & R11). Another nifty thing about this IC is that you can add turn ON/OFF hysteresis (controlled by R3 & R13). This is useful for when you want to disable/enable the IC if there is not enough/heaps of sunlight, and with this circuit this threshold is set at 3.2V & 3.5V respectively.
  • The second stage is based on the LTC3539 (USB) DC-DC converter. This one is really neat as such a small package (3mm x 2mm x 0.8mm) can deliver up to 700mA at 5V (from 2.4V). In my circuit I use two of these in parallel to boost 2.4V (2S1P NiCd pack nominal voltage) to 5.1V (set by set by R23 & 29 or R25 & R33). The reason why I set the output to 5.1V instead of 5V is to try and deal with any resistive losses encountered when using a poor USB charging cable. Interestingly enough the USB 2.0 standard states that the power bus voltage (5V) may vary by as much as +0.25V to -0.60V, and since 5.1V is well within these limits the circuit is not going to fry phones/cameras any time soon.
  • The final stage marked as “Capacity Checker” does exactly that. Here I use the very crude method of loading the NiCd pack with a 1A load, measuring the resulting pack voltage, and comparing it against a set threshold (see battery characterisation section). If the measured pack voltage is over a given threshold, then the corresponding LED lights up. I also power (and set the reference of) the comparator with 3.3V instead of 5V to try and increase the voltage resolution.

Lastly I should note a couple of points about the overall circuit:
  • The inductor values for each DC-DC converter were picked by running a number of simulations in LTspice. The goal was to pick a value that resulted in the best response and overall efficiency; interestingly enough the optimal inductor values were ones that had the lowest coil resistance.
  • As I mentioned before I went a bit overkill on most components, for example:
    • I chose inductors that had the lowest possible coil resistance to minimise DC losses. And as you might know this requirement usually translates to physically large components (compare the IC to the big black cube right next to it).
    • I chose polymer aluminium electrolytic capacitors when normal electrolytic’s would have worked fine. But since these have extremely low ESR for a bulk capacitance I could enjoy the benefits of low resistive losses. 
    • Lastly I used Linear Technology IC’s for the DC-DC converters. These are known to have superb performance but come at a cost of well… loadsamoney.

Here is a render of the PCB in Altium:

Here is the BOM (Bill of Materials) for the circuit:

Mechanical Design - SOLIDWORKS

And here is how the case assembly looks like in SOLIDWORKS.

Simulation vs Real-life

It’s always interesting to see how simulations perform compared to real-life, so here are a couple of graphs that show just that. I was really surprised to see that the LTC3130 (Solar) performs better in real-life across the entire output current range. Sadly, the same can’t be said for the LTC3539 (USB) which only performs better up to 0.15A at which point the efficiency drops off drastically compared to the simulation.

It was also interesting to see that the peak efficiency of the LTC3130 (Solar) is ~85%, while for the LTC3539 (USB) it’s ~90%. You might recall my goal was to achieve at least 90% for both, and I can truthfully say I am pretty much there :D

Mistakes, Problems, & Final Thoughts

  • Turns out if you want to have a USB 2.0 charging port the D+ & D- (data) pins must be tied together via a 200R resistor. If you forget to do this, then your port will be limited to 0.5A (no quick charge for you).
  • For this circuit the 5.1V is load dependant, and usually floats between 4.96V to 5.07V. From what I can tell this is because I am trying to have two LTC3539’s (USB) in parallel, something that the IC’s were not designed for (otherwise there would be a SYNC pin).
  • Another annoying thing about running two LTC3539’s (USB) in parallel is that your voltage setting resistors have to be very very accurate (I’m talking spending two hours measuring 0603’s with tiny probes accurate). Otherwise one DC-DC converter might try and force the other once to sink current, something this IC is not designed to do.
  • The SoC (State of Charge) circuit is not that great as the threshold voltages seem to have quite a large error with them. I tried swapping U5 from an LM239DT (TTL, Transisor-Transistor Logic) to a TLC3704ID (CMOS, Complementary Metal-Oxide-Semiconductor) but this did not help that much.
  • A toggle switch is not the best option for something that might get dropped. Currently the ON/OFF switch is semi-broken, will need to swap this for something sturdier.
  • Making an efficient solar battery charger is all fine and dandy, but I really need something to compare to. Will have to order a cheapo USB solar charge off eBay and characterise that for comparison.

At the end of the day I managed to make a neato solar battery/usb charger that is fairly efficient too. It’s been field tested across Israel, Ukraine, Russia, Hong Kong, and Australia, and will hopefully survive the next 10 years of abuse. To close this of, here are some action shots:

Monday, February 13, 2017

UPDATE: Etsy & Tindie Shop Open

You might recall that a while back I made this wedding announcement trinket/figurine. Well not long after I decided to try and make a more marketable version. I started working on this in early November 2016 but then put it on hold as other projects took over. Recently I started working on it again and managed to finally finish it off in the weekend.

To give you an idea of how the figurine design evolved here is an image of the different revisions. The other thing this shows is my painful progress with driving SOLIDWORKS ;^)

Here is the final product:

And a video to show it all off:

Finally if you like what you see, you can get it from:

Monday, January 23, 2017

PROJECT: The Vidya Gaem Awards - 2016

As the name suggests the /v/ga's are an online awards ceremony organised by a small group of /v/ users. What you might not know is that these guys have been going strong since 2011. This year they decided to make the awards cyberpunk themed. Since this is my favourite genre I wanted to make something cool for the ceremony. 

In the end monoframe came up with a design for a neon sign which I made using side emitting fibre optic cable and a few powerful LED's. I was also lucky enough to have the design/build video chosen for the announcement trailer, which you can view below:

Sunday, November 20, 2016


My partner saw a neat tutorial on how to make a simple cellphone powered LED light, basically it uses a DC-DC converter to step the μUSB port voltage from 5V to ~3.7V. The problem I saw with the simple design was that there was absolutely no current limiting or over-voltage protection on the phone μUSB port, this can be a bit of a worry if your phone was designed without them in mind. So another idea was born, make a similar device that offered these safety features.

Component Selection

Having a look through DigiKey I found this neat little IC, the PAM2863ECR, which fit the description perfectly and even had the ability to control the current flowing though the LED (thus adjusting it's brightness). For circuit protection I added a 5.6V zener diode (MMSZ5232B-7-F) on the μUSB power line followed by a 0.5Atrip resettable fuse (MF-PSMF020X-2). Finally for the light source I went with the TL1F1-NW1,L(S which was a cheap yet powerful LED I managed to find on Element14.

Circuit Design

Next up I drew up a schematic in Altium and started the PCB design. One thing to note is that the LED and IC both have power losses with the LED being so significant that sufficient cooling (usually in the form of big copper planes) is required for the LED not to cook itself. As an experiment I decided to completely ignore these and see if I can get away with a tiny board (man I must have some sort of fetish for small PCB's...), here is that the board was going to look like:
And here is how it actually came out to be, minus the μUSB connector:

Lessons Learned

Surprise surprise the device did not function as expected here is why:
  • You guessed it the tiny PCB did not have adequate heat sinking capability, this caused the LED & IC to heat up to ~150°C, a fair bit over their rating... One interesting this I did get to witness was the LED slowly failing, you could see the current being constant but the brightness slowly fading away.
  • Something else I should have expected was the voltage drop across the resettable fuse. This reduced the IC input voltage from 5V to ~4.5V, and since it's minimum voltage is 4.5V it did not behave as designed. Removing the resettable fuse solved the problem, until the whole thing got hot again...
All in all i r8 an 8 outta 8, good reminder on the things to look out for when designing a circuit like this. 

Thursday, November 17, 2016

PROJECT: EMG Amplifier, Update #1

Sometime around mid this year I decided to make an Electromyography (EMG) amplifier circuit. This idea came alive because I like the though of human augmentation, and making something along these lines would be super neat.


So I set out on my journey of learning, reading many Masters/PhD papers to try and see what exactly makes an EMG signal and how to successfully amplify/capture it. From this I found:
  • The easiest way to capture an EMG signal is by using an Instrumentation Amplifier (IA), this is because unlike normal amplifiers these have a super high input impedance which does not collapse the waveform.
  • Another neat thing about IA's is that they have a high Common Mode Rejection Ratio (CMMR), this means that any unwanted signal present on both inputs (such as the annoying 50Hz hum) will get automatically attenuated/"removed".
  • One way which you can further process the signal is by using an active filter, this allows you to filter out any frequencies that you are not interested in. For example the range I was interested in was 50Hz ➝ 200Hz.


With that knowledge in hand I then designed the active filter circuit with the help of the electrical engineering bible (The Art of Electronics), and simulated the circuit in LTSpice:


After a few more iterations and additions I then decided to jump the gun and design an actual PCB:
Board all laid out and ready for OSH Park.

Breadboarding, what I should have done at the start...

My Band Pass Filter almost working as expected :D


Though this was the densest board I have made to date (2-layer 50mm x 30mm) rushing and making the board without first prototyping the circuit turned out to be a big mistake, as I learned:
  • Trying to assemble a board full of tiny components is tedious, especially if you don't have a solder paste stencil. 
  • Not all components are designed equal and some can withstand heat better than others, this is what happened to the heart of the circuit as all amplifiers were cooked to death ; - ; luckily I had a few boards and components to spare.
  • Trying to debug a busy board like this is not fun. In the future I should either make it on breadboard first, or add lots of jumpers to be able to bring sections in/out, plus lots of accessible test-points would not hurt as well.
  • Experimenting too soon can really mess things up. My downfall was that I decided to try and use two SIM card contacts as the EMG contact, when instead I should have started off with something that I knew would work (like this). Again this made debugging harder as I did not know if it was the circuit or contacts at fault.
  • As I mentioned earlier your IA needs to have a high input impedance, using the INA827 instrumentation amplifier was not good enough. Something like the INA826 (yeah I'm cheap) would have been better, 
  • If you do decide to power your circuit from a single rail (as in Vcc to GND not Vcc to Vss) make sure your amplifiers are designed for it. With my circuit I initially went with TL974 when I should have gone with something like MCP6004.
  • An addition to above, make sure that any active elements are also designed to work from a single rail. For my circuit the active full-wave rectifier was designed to work from a dual rail supply...
So now the project is on hold as other things have taken over, but I do look forward to coming back and getting this thing finally working :D

Friday, June 3, 2016

PROJECT: Wedding Announcement Puddycats

Good news! The fiance and I are getting married sometime in 2017 :D

To announce this awesome turn of events her and I decided to make a cool little gift for our family. In the end the trinket ended up being a couple of 3D printed cats that were lit up by an ever-changing rainbow from two RGB LED's. 

Circuit Design

Schematic wise the project is quite simple, just a single ATtiny25 microprocessor that "powers" some Red Green Blue (RGB) LED's. When I say power I really mean it provides a Pulse Width Modulated (PWM) sink for the LED's since they are common anode (notice how the anode of each LED is connected together), we can vary the brightness of each colour by setting the PWM duty cycle which in the end allows us to pretty much cycle though the colours of the rainbow (plus pink). Also all of this is powered by a single CR2032 battery as seen by the following schematic
Since the circuit is powered by a single coin cell battery I had to be somewhat efficient with the design, the end goal was to make the trinket last for at least a day. With that known I started looking for RGB LED's that:
  1. Were easy to solder by hand
  2. Had a good brightness at a forward current of ~2mA 
  3. Had a forward voltage drop of <2.9V for the Blue and Green LED, this is because a CR2032 battery has a nominal voltage of 3V
After a few orders from Element14 the best option seemed to be the ASMB-MTB1-0A3A2 

Next I picked the current limiting resistors (R1➛R6) such that the forward current through each LED (at max brightness) was ~2mA. As trivial as it sounds there is no simple solution to this problem, as the battery voltage is not constant throughout it's discharge cycle (it gets lower the more depleted it becomes) so finding a resistor that would limit the current to 2mA through the discharge process is impossible. After juggling factors like LED brightness, trinket lifetime, and average battery voltage I came up with an "optimal" resistance of 523Ω for the Red LED, and 75Ω for the Blue and Green LED.

Lastly when making any circuit that switches ON/OFF continuously (this is what the microprocessor does in this case) it's always a good idea to use some decoupling capacitors on the power rails. In my case since the ATtiny25 was output a bunch of PWM signals to be on the safe side I used two decoupling capacitors C1 & C2, both of which were the typical 100nF X7R ceramic type.

PCB Layout

Another goal was to have the trinket small in size, preferably as wide as the CR2032 battery holder. To achieve this I had to move to Surface Mount Technology (SMT/SMD), something that was quite new to me since all my previous projects utilized Through Hole components. With the packages specified I then designed the PCB in Altium, laying out the components in the following manner:
NOTE: I made all the footprints using Library Expert Lite, where as the 3D models were mostly simple body extrusions made in Altium. Come to think of it I should have used 3DContentCentral as they have all sorts of 3D models available at no cost.

Next step was getting the PCB's made, for this I went to PCBshopper to compare various fabrication houses. In the end I decided to go with OSHpark who are recognized for their quality and have the very distinctive purple/gold look. 

To get the boards made you need to supply the fab house with Gerber & Drill files for your design. Basically Gerber files define what each layer of the PCB contains, be it numbering/pictures on the top/bottom surface, tracks of copper, or solder mask. Whereas a Drill file tells the fabricator what drill size to use for each hole on the PCB. With OSHpark since I requested a simple two layer board the files I had to provide were thus:
  • Top overlay/silkscreen (GTO)
  • Top solder mask (GTS)
  • Top copper layer (GTL)
  • Board outline on mechanical layer (GM1)
  • Bottom copper layer (GBL)
  • Bottom solder mask (GBS)
  • Bottom overlay/silkscreen (GBO)
  • Drill location & size (TXT)
NOTE: Here I used the 1st Mechanical layer (GM1) to define the board outline. You can use any layer for this BUT make sure to not to use the same layer for other things like annotation, otherwise the fab house might get confused with the intended board shape... something that I found out the hard way.

Trinket Construction

To make soldering easier I decided to get the YIHUA 858D, a cheap hot air gun made specifically for soldering such small components. Here is a video of me soldering the "jelly-bean" parts with the hot air gun, something that would have taken much longer to had I used the soldering iron.

The rest of the components though small were easy enough to do by hand with the soldering iron.

Next up I printed the trinket body using my Prusa i3v 3D printer; the body consisted of a simple base which hid all the electrical components and two cats which got lit up by the RGB LED's. I should mention that the cat model is not mine and that you can grab it from the designer here. To make the cats hollow and the base filled I had to use two different print settings. For 0mm to 3mm the body (base) was printed with normal infill while for 3mm onwards the body (cats) was printed hollow; all of this was achieved by combining two different print parameters in Simplify3D. If you want the modified cat model you can grab it here.
Also to hold the PCB and 3D printed cats together I used countersunk M2x10mm bolts with M2 nylon lock nuts.

Trinket Programming

Programming the trinket would have been easier had I used a dedicated programming header like this, but since space was a priority I skimped on the header and instead used a SOIC chip clip. To give you an idea of how the programming went down have a look at the following video:

One of the interesting/unintended things I found was that an unprogrammed board would light the LED's red in colour, giving a neat way of checking the microprocessor status on each PCB.

The code for the above "rainbow scroll" effect can be seen below. If you plan to upload the code using an Arduino as the ISP (like myself) then make sure to grab this ATtiny library; if you want to know why then have a look at this post. To give you a summary the ATtiny easily supports two PWM outputs, if you want three/four (recall this project utilities three) then you need to jump through some hoops to get this functionality, using the above library does this for you and so makes programming a bit easier.
// Wedding announcement LED's                                        //
//                                                                   //
// PARTY HARD & VapeNash Ya'll                                       //
// Use this atTiny lib:          //
//                                                                   //
// ANTALIFE - 20.04.16                                               //

const int t_delay = 100; //100 seems best
const int pin_R   = 0;   //Red LED on PB0 (pin 5)
const int pin_G   = 1;   //Green LED on PB1 (pin 6)
const int pin_B   = 4;   //Blue LED on PB4 (pin 3)

void setup() 
  //Setting up muh e-peenz
  pinMode(pin_R, OUTPUT);
  pinMode(pin_G, OUTPUT);
  pinMode(pin_B, OUTPUT);

void loop() 
  //RED -> GREEN
  for (int rg = 0; rg <= 255; rg++)
    analogWrite(pin_R, rg);
    analogWrite(pin_G, 255 - rg);
    analogWrite(pin_B, 255); //Blue LED not used so stays OFF
  for (int gb = 0; gb <= 255; gb++)
    analogWrite(pin_R, 255); //Red LED not used so stays OFF
    analogWrite(pin_G, gb);
    analogWrite(pin_B, 255 - gb);
  //BLUE -> RED
  for (int br = 0; br <= 255; br++)
    analogWrite(pin_R, 255 - br);
    analogWrite(pin_G, 255); //Green LED not used so stays OFF
    analogWrite(pin_B, br);

Trinket Testing

Doing a quick test with my uCurrent (red box in photo) showed that the average current draw was around 7mA [I_draw], meaning that on a 240mAh [capacity] CR2032 battery the trinket would last [t_on] for just under a day and a half:

t_on = capacity ÷ I_draw
t_on = 240mAhr ÷ 7mA
t_on ≈ 34hrs

Actual tests showed that on a cheap CR2032 battery the trinket would last for just over a day, mission success :D

Trinket Showcase

Finally here is a video of a bunch of trinkets doing their thing: