0000 0000 0011 1010

Monster Mailbag (Part Two)

Only for the dedicated, here is part two of the "Monster Mailbag". Feedback welcome!

Next week I return to making stuff, in this case an LM386 amplifier with a bit of blog history - and a new partnership as well.

0000 0000 0011 1001

Tripping the light - fantastic!

After some gentle (?) banter regarding the size and number of buckets of electronics about the place, it was suggested to me by a long time collaborator that the door at the bottom of the staircase into the garage could use some incidental lighting (e.g. before the main lights at the wall are flicked on).

A normal person presumably would go to a hardware store and spend $20 and 15 minutes to fix the problem. Clearly I'm not normal, and so I started a project which could either be labelled:

1. Lighting the garage upon detecting a human presence, or
2. Justification (in part) for the many buckets of electronics clogging up the place

The first order of business was planning the physical elements of the project (see video) and then a quick (and dirty) circuit diagram showing the relevant parts orchestrated to achieve the desired outcome.

At the heart of the project is an ATTiny13 (of course) which is asleep. If the door from the stairwell is opened then a hall effect sensor is tripped and the μC wakes up and brings up the LED strip via a transistor. Alternatively from the opposite direction if a warm humanoid stands in front of a PIR then the μC also trips and provides light. I've chosen components that use very little current and so overall the circuit consumes around 500μA when "asleep".

AM312 Mini-PIR at ~15μA

Hall Effect sensor at ~1μA

Voltage regulator at ~1μA 

I then mocked up a prototype, wrote some code and soldered up the "PCB of Goodness".

// -----------------------------------------------------------------
// Description: A strip of Leds connected to a transistor controlled
// by an Attiny13. The μC sleeps most of the time, but is interrupted
// by a PIR on PCINT1, or a Hall Effect sensor on PCINT2. It will then
// light the leds, hold for a bit and and then fade out.
//
// Author: OneCircuit      Date: Thursday 16 July 11:48:26 AEST 2020
// www.onecircuit.blogspot.com
// www.youtube.com/channel/UCTm3eCrN6wk-Ozt9ymyKIIg
// -----------------------------------------------------------------
//
// ATMEL ATTINY13 μC
//
//                                   +-\/-+
//  RESET--ACD0--5/A0--PCINT5--PB5  1|    |8  VCC
//   CLKI--ACD3--3/A3--PCINT3--PB3  2|    |7  PB2--PCINT2--2/A1--SCK--ADC1
//         ACD2--4/A2--PCINT4--PB4  3|    |6  PB1--PCINT1---1---MISO--OCOB--INT0*
//                             GND  4|    |5  PB0--PCINT0---0---MOSI--OCOA*
//                                   +----+
//  * indicates PWM port
//

#include <avr/pgmspace.h>            // for reading the progmem values
#include <avr/interrupt.h>           // for interrupt routines
#include <avr/sleep.h>               // the sleep routines

#define StripLED PB0                 // pwm pin
#define HEPin PCINT2                 // Magnetic interrupt pin
#define PIRPin PCINT1                // PIR interrupt pin

volatile boolean triggered = false;  // boolean for keeping track of interrupts

// The led strip will fade exponentially to compensate for human perception,
// which is not linear. You can calculate as a curve, but float values will blow
// the little Attiny13 out of the water, so a lookup table in progmem makes more
// sense for saving memory.

const uint8_t PROGMEM gamma8[] = {
  0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,
  5, 5, 6, 6, 7, 8, 8, 9, 9, 10, 11, 11, 12, 13, 14, 14, 15,
  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
  30, 31, 32, 34, 35, 36, 37, 39, 40, 41, 43, 44, 46, 47,
  48, 50, 51, 53, 54, 56, 58, 59, 61, 63, 64, 66, 68, 69,
  71, 73, 75, 77, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96,
  98, 100, 102, 105, 107, 109, 111, 113, 116, 118, 120,
  123, 125, 127, 130, 132, 134, 137, 139, 142, 144, 147,
  150, 152, 155, 157, 160, 163, 165, 168, 171, 174, 176,
  179, 182, 185, 188, 191, 194, 197, 200, 203, 206, 209,
  212, 215, 218, 221, 224, 227, 230, 234, 237, 240, 243, 247, 250
};

void slowfade(boolean fadein) {

  if (fadein) {
    for (uint8_t lighting = 0; lighting < 150; lighting++) {    // 150 steps
      analogWrite(StripLED, pgm_read_byte(&gamma8[lighting]));  // read from the lookup table
      delay(6);                                                 // increase for a slower fade
    }
  }
  else {
    for (uint8_t lighting = 150; lighting > 0; lighting--) {    // count backwards
      analogWrite(StripLED, pgm_read_byte(&gamma8[lighting]));  // from the lookup table
      delay(80);                                                // increase for a slower fade
    }
  }
}

void powerDown(void)
{
  GIMSK |= (1 << PCIE);                   // activate Pin change interrupts
  PCMSK |= ((1 << HEPin)|(1 << PIRPin));  // sets the Pin change interrupt mask
  ADCSRA &= ~(1 << ADEN);                 // turn off ADC
  ACSR |= (1 << ACD);                     // turn off Analog comparator.
  sei();                                  // enable global interrupts
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);    // sleep deeply little one
  sleep_enable();                         // enable sleep mode
  sleep_mode();                           // system sleeps here

  sleep_disable();                        // ISR routine returns here so wake up
  GIMSK &= ~(1 << PCIE);                  // deactivate Pin change interrupts
  ADCSRA |= (1 << ADEN);                  // turn on ADC
  ACSR = (0 << ACD);                      // turn on Analog comparator.
  delay(100);                             // settle time after waking up
  
}

ISR(PCINT0_vect)
{
  triggered = true;
}

void setup ()
{
  pinMode(HEPin, INPUT_PULLUP);    // configure interrupt pin as input
  pinMode(PIRPin, INPUT_PULLUP);   // configure interrupt pin as input
  pinMode(StripLED, INPUT);        // LED pin input to start

}  // end of setup

void loop () {
  if (!triggered) {
    powerDown(); // call the function that sleeps
  }
  else {
    pinMode(StripLED, OUTPUT);    // LED pin is now output
    slowfade(true);               // fade in
    delay(60000);                 // hold that thought for 1 minute
    slowfade(false);              // fade out
    pinMode (StripLED, INPUT);    // configure transistor pin as input, saves power
    delay(1000);                  // one second before re-trigger
    triggered = false;            // reset boolean
  }
}  // end of code

Finally after testing the new device was installed and currently it lights up when either the door is swung open, or a human is detected via PIR. Mission 1 outlined above - accomplished. Mission 2 - ongoing...

0000 0000 0011 1000

Monster Mailbag (Part One)

After very little action in the mailbox for weeks (thanks "Pandemania"), and after going away for a week on holidays on our world-wide tour of Tasmania - the postbox was uncharacteristically bursting with mail upon return!

It seems that the freight lines from China are back in action - or maybe the local lines are unclogged after lockdown, but either way we are seeing some items ordered back in March suddenly arriving. I have stopped instigating disputes in AliExpress on the assumption that most stuff will turn up at some time - hopefully before I forget what I was thinking when I pressed the big red "ORDER" button! 

Here is the list of items covered in the video:

There were way too many packages for one video, so here is "Part One" and I'll post the second part in a couple of weeks.

0000 0000 0011 0111

ATTiny Programming

You do not need a fancy programming shield to program an ATTiny13 or ATTiny85. Early on when I first bought the ATTinys I used an Arduino Uno (I didn't have any Nanos at the time) and simply hooked them up according to instructions I found on the internet. They programmed up fine, but if there were any problems it was usually dodgy breadboards, crude code or me bricking chips with poorly programmed fuses.

Just a Nano and some wires needed

Later I saw the ATTiny ISP Shield from htlinux on the webnets - and I found that this device was way more reliable PLUS it had the added bonus of being able to easily program 14 pin and 20 pin ATTinys (although it seems that in the end this was just an excuse to covet more microcontrollers).

Programming Shield

One day foraging in the AVR backwaters of the internet I discovered the most marvellous programming shield designed by Jia Huang. She made the gerber files available on her github and from memory this was my first (nervous) order I placed to a PCB manufacturer.

When the batch of ten arrived I was so excited that I soldered the first one upside down which was interesting but definitely not functionally useful! It now sits proudly in "The Jar Of Shame™" with my other electronic abominations.

The next one I soldered (properly) worked great and then I was able to program not only my ATTinys, but also for the first time a bare ATMega328 IC (which will be a topic for another blog).

So lovely, and useful

I was pretty happy with this shield as my main programmer (via the UNO) for some time, until I found Łukasz Podkalicki's amazing ATTiny13/85 PCB - and again I had to download the files and have them made, with only a couple of minor modifications.

Two programmers and a wayward capacitor

It allowed me to use a USBasp programmer to quickly load code to the little AVR and as well it opened up many other programming possibilities. For example, I could now use AVRDUDESS to harness the power of avrdude, and also upload directly to the AVR hex files made, for example, from my own handcrafted assembly instructions (e.g. via Gerd's AVR_SIM).

When the freight situation around the world resolves (thank you pandemania!), I'll pop these little beauties onto my Tindie store in case anyone would like to try one - they're great!

In the meantime, see below for a video of me soldering up one of the ATTiny programmers from scratch, and then using all of the options written about above, including the little PCB, to make...er...a blinking LED!

0000 0000 0011 0110

Yellow 5050 LED - awesome for any candle project

There are many candles of shame scattered around our house - early experiments with multiple LEDs (types and colours) in an attempt to produce the elusive Holy Grail of a lifelike flame emanating from an electronic device. 

In the quest for authentic fakery I firstly tried different colour combinations of orange, red, yellow and warm white searching for a good flame effect. Early recipients of these efforts (sorry...) were sometimes honest in their appraisal and I thank them for their feedback. I suspect a few of those "candles" are carefully filed in truncated inverted conical open ended filing cabinets now.

I tried 3mm, 5mm and various SMD LED formats from different suppliers as part of the experiment. I covered various LED combinations in hot glue, half table tennis balls, grease proof oven paper, tissues, and anything else diffusive that I could find around the house. They're all good in their own way, but ultimately none really were candle-like for various reasons.

All those failures helped focus the requirements for the source of light at the same time I was fiddling with the code looking for acceptable "randomness" to drive the flame.

Early prototype - "white" flame from hot glue

Then one day in 2018 I was skiing virtually through the LED valleys on the internet when I came across a 5050 format LED which seemed to have three pins in and out - surely not! Three LEDs in one - that's heaven for someone looking for a compact controllable efficient package.

I ordered red, orange, yellow, warm white and cold white versions and then sat by the post box in anticipation. All the colours were interesting, but the yellow version was oh so lovely as a candle, and all recent recipients have reported a pleasing realistic candle-like glow emanating from the devices.

The candle project at the time (and still now) has two independently ramping PWM channels, one of which supplies a randomly varying "slow" steady up and down ramp and the other a randomly varying "fast" flickering ramp which gives a little more "life" to the "flame".

The slow ramp signal outputs to two of the LEDs in the package and the fast ramp to the remaining LED. Daredevils could reverse this for a more intense flame. There were some other "breakthroughs" after discovering this LED package. A friend mentioned that the hot glue flame was a bit woeful so I bought some little uniformly round fresnel lenses to help diffuse the glow.

Also I started to put the LED combo on the inside of a glass jar (they used to be hilariously stuck on the outside) and with the inside of the glass jar sprayed with a bit of diffusive white paint, the result was a warm diffuse candle-like ambience. It also helps if the jars are contoured to refract the light more realistically.

Whether the candle is powered by an old battery or rechargeable via a solar panel is irrelevant to the flame quality - but I definitely prefer the solar version for ease of use and sustainability.

0000 0000 0011 0101

CD4051 multiplexer/demultiplexer

For a long time I wondered why anyone would ever buy any of these cheap old school logic chips. Why not just use a microcontroller? Then one day I caved in and bought a few shift registers, and now years later I have buckets of lovely chips that give me great delight, and inspire me to make a few interesting circuits as well.

None more so than the versatile CD4051 (and it's cousins CD4052 and CD4053) which I am sure will appear on this blog more than once. They are multiplexer/demultiplexer ICs, which is a fancy way of saying that a few wires from the microcontroller (or indeed just a couple of buttons) can make for multiple outputs or inputs.

The first thing to establish is if the chips work or if they are full of tiny socks (long story). I hooked up a CD4051 chip with some simple buttons and LEDs to demonstrate the truth table shown below.

The "enable" pin is pin 6, and the "input/output" mode is selected from pin 3. On the breadboard above you can see the button on the left is select/com (input when low, button not pushed, output when high, button pushed) and then the three buttons on the right connect to A (pin 11), B (pin 10) and C (pin 9) respectively.

Then I've just hooked up some LEDs to A1 (pin 14) and A2 (pin 15) for toggling output, and LEDs to A5 (pin 5) and A7 (pin 4) for toggling input. The input LEDs do not carry as much current and seem to be dimmer.

After establishing that the chip was functioning, I then thought about how it could be used to select for different voltage outputs using a couple of voltage dividers. For instance from a single supply can we digitally select different voltage outputs (e.g for different sensors in the same circuit). Some back of the envelope calculations (actually using this site) gave me the idea of wiring up four 1206 resistors as follows.

Now if I could change the outputs of the CD4051 using the buttons, then I could selectively change the voltage using the dividers. Output A1 gives 5V and output A2 gives 3.3V.

Note that the voltage for the breadboard needs to be higher than 9V (in this case 9.3V) to give 9V at the divider thanks to a slight voltage drop across the CD4051. Note also that due to the 1206 resistors being a little inaccurate (+/- 5%), the 5.0V divider is a tad high and the 3.3V divider is a bit low!

Finally, I wanted to make this voltage divider digitally driven by my old friend the ATTiny13a instead of using my sausage fingers to mash buttons as seen above. I thought that the process of switching to a microcontroller was going to be easy, but it wasn't!

Firstly, the ATTiny13a would definitely not be happy with a 9V VCC rail, so I had to bring in an LM7805 linear voltage regulator to supply it with a more palatable 5V.

Secondly, I could not get 9V output from the CD4051 with a 5V signal (Duh! It's an analog multiplexer/demultiplexer) so the voltage divider was only being fed the 5V output from the CD4051 and therefore wasn't making the 3.3V and 5V I had calculated.

To fix this issue I firstly brought in a couple of transistors (SS8050 NPN) to switch 9V for the divider. Of course the NPN has load on the collector side and therefore the voltage divider was either at 9V when not switched by the transistor or at 5V or 3.3V when switched. So out comes the NPN and in goes the PNP 2SA1020 which worked fine (see diagram below).

Finally the voltage meters were blinding me at 9V (and 5V), so I also swapped in a separate 3.6V power rail for them (with a common ground) so that they weren't dazzling the camera.

It ended up being a bit of a Frankenstein circuit, but the concept does work!

Only a little bit of code was needed for the microcontroller to flip the transistors on and off.

void setup() {
DDRB = 0b00010111; // PB0, PB1, PB2 and PB4 set as OUTPUT
}

void loop() {
PORTB = 0b00010100; // PB4=1, PB3=0, PB2=1, PB1=0, PB0=0
delay(1500);
PORTB = 0b00010000; // PB4=1, PB3=0, PB2=0, PB1=0, PB0=0
delay(3000);
PORTB = 0b00010010; // PB4=1, PB3=0, PB2=1, PB1=0, PB0=0
delay(1500);
PORTB = 0b00010000; // PB4=1, PB3=0, PB2=0, PB1=0, PB0=0
delay(3000);
}

Purists will note that I could have just switched the transistors directly using just two output pins from the ATTiny13a without the need for the CD4051 at all, and as there are only two pins required for the voltage divider they would be correct!

But if more outputs are needed then the addition of a CD4051 makes the sacrifice of three output pins needed from the ATTiny13 worthwhile. For instance, I can add some code to make a few nice flashing LEDs - not because I like flashing LEDs of course, but because it proves the worthiness of the chip - right?

0000 0000 0011 0100

Joule Thief stable output development PCB

I have pushed the button on so many PCB designs in the past that I now look back at the older iterations with a degree of regret. I have come to recognise and appreciate the value of this digital evolution because I learned a lot in the process - but I still want the money and all of that development time back please!

The design I'm going to look at in this blog is the stable joule thief PCB shown in an earlier blog. To be fair to the circuit it has always worked well in each iteration, and I have always hurriedly opened up the packets from the manufacturer, soldered them up and huffed and puffed about the place quite...er...chuffed.

But...the latest incarnation is the huffiest, puffiest and chuffiest I think (well, until the next one I guess). The requirements for the PCB have changed over time (along with my understanding of PCB design). 

Originally the PCB was specifically developed for a dedicated night-time "candle" project, but the project evolved to require the following:

1. Stable voltage output for running a microcontroller
2. All pins of microcontroller broken out
3. Solar panel input to rechargeable battery if required
4. Breadboard friendly for development
5. Less SMD and more through hole components for ease of soldering

Blurry for a reason - not proud of all of these!

All versions do work as intended, but the latest is really nice as it fulfils all of the design criteria. Here are the steps along the way.

As per usual as soon as the PCB arrives and is soldered up I am already thinking of the next iteration, but in this case the result is so useful I've thrown it on my Tindie Store in case anyone might find it useful/fun as well.

Next I want to use two QX5252 ICs and (maybe) drive the output throughout the day when a solar panel is connected (at the moment using one QX5252, the output current is shut off when charging the battery). I get the feeling that I might be doing iterations of this damn thing for a few years yet! And loving it...