Friday, 19 July 2019

KiCad Kata

Pretty (but dumb) LED Matrix
The picture shows the result of another workout with KiCad as executed by Seeed Studio and finished by me. This looks rather prettier than the original and was considerably easier to solder, not to mention more LEDs!

However a few defects are obvious too:

  • the LED spacing is wider than on stripboard, which can make patterns harder to discern
  • the interface split between anodes and cathodes is the same as the original, for no good reason
  • it now uses 16 gpios!
The first and second of these are my fault but the last could have been mitigated by adding an LED driver, such as the MAX7221 to the design:
MAX7221 DIP package
This particular chip requires only a couple of capacitors and a single resistor to function (see the circuit here). Also it is cheap, less than €1 from China and has a mature Arduino library. It could comfortably have fit in the space occupied by the resistors on the left of the picture. On the downside, it requires a 5v supply. (The Arduino playground has a lot of information about it.)

So, it was instructive to lay out an LED matrix and write a library for it, and I'd encourage you to try it for yourself. (However I also won't blame you for simply buying one on eBay, they seem to be cheaper than the cost of parts somehow!)

Wednesday, 17 July 2019

At the Margin

(Who knew that the Economics of Seinfeld was a thing? Given that it was the first link returned by Google, everyone but me I guess!)

The idea of "marginal cost" is usually in mind when I'm preparing a PCB order from Seeed Studio. That's because their product is cheap and high quality but shipping rates are high. This means that it's almost free to load up an order with small items which would not of themselves justify the total cost.

This post describes a couple of such items, which gave me practice (I'm learning KiCad) yet took no longer than a few hours to produce.

The first of these is a breakout board for the (pre-ESP8266 anyway) ubiquitous nRF24L01 radio module. Its main advantage is its low power, allowing projects using it to run off batteries. Its main disadvantage is its breadboard-hostile pinout. Enough said: see picture below.
nRF24L01 breakout
Sparkfun does something similar; however theirs is better, and more expensive! I kept mine pin-compatible though, because why not?

Next up is a breadboard-friendly development board for the attiny84. This had been on my maybe-list for a while but it was only when I discovered Spence Konde's awesome Arduino core for ATtiny that I decided to go for it. The presence of Optiboot sealed the deal for me: the pin header allows sketch upload via a standard FTDI dongle.

attiny84 devboard
Lastly, just to show that they both play nicely together, the pair wired up, and programmed with a sketch using my ATtiny port of the RF24 library (originally written by Maniacbug of course).
All together now!

Wednesday, 22 May 2019

Soldering Kata

7x7 LED Matrix
When I were a lad, LEDs were a big deal, literally: £1 each. Now someone in China manages to make a living selling them for £1 for 100. With inspiration provided by an Instructable, a rainy afternoon and the need for some soldering practice I set to work.

The Instructable's, err, instructions were clear enough:

  • take a piece of protoboard (the sort with pads instead of strips)
  • solder each row of LEDs anode (longer) first to hold them in place
  • cut the cathodes to size and bend them through 90 to connect each row's together
  • test each row after soldering!
  • I then cut a piece of stripboard ("veroboard") into single strips and connected each column's anodes together in a sort of DIY dual-layer PCB arrangement, see below.

Rear view: anodes connected in columns

The last step was the only point where I deviated from the instructions. (I first attempted to fit a single piece of veroboard over all of the anodes but found this impossible: there was too much variation in their positions. Perhaps aligning each row of LEDs as it is soldered using veroboard might work?)

Next: mount vertically on breadboard, add a handful of resistors (470R) and connect to an Arduino!

I wrote an Arduino library for it, available on Github. It contains a couple of examples, the simplest can be seen running below. (The moving light makes keeping the camera focussed impossible, sorry.)




The disadvantages of this bit-banging approach to driving an LED matrix are fairly well-known:
  • it uses an excessive number of GPIOs (14 here)
  • the GPIOs themselves can't supply very much current, so the more LEDs lit, the dimmer they are
  • PWM-style dimming is not practical
  • timing is tricky: since it relies on persistence of vision to work, each refresh cycle must take no more than 40ms
For all of these reasons, using a dedicated driver chip is recommended. More when my MAX7221 (another £1) arrives on the ship from China in a couple of weeks!

Friday, 1 June 2018

It speaks!

Porting TTS to the ESP8266 processor has been on my to-do list for a while now, prompted by a comment on an issue I'd created to remind me. To do this, I realised that I'd have to reacquaint myself with PWM on the ATmega328p.

At its most basic, a PWM waveform is a square-wave with a varying duty-cycle. Both the frequency of the square-wave and the duty-cycle are determined on an AVR by the its built-in timers. PWM on Arduino pin 9 (hardware pin 15, OC1A), for example, is driven by Timer-1, a 16-bit timer.

Several PWM modes are available; TTS chooses the "phase and frequency corrected" option.


The diagram shows how this works to change the duty-cycle of the output pin:
  • the timer counts from BOTTOM to TOP and back down again
  • when it crosses the OCR1 threshold going up, it sets the OC1A output high,
  • when it crosses this threshold on the way down again, it sets the OC1A output low. 
Therefore by dynamically changing OCR1, we can change the "volume" on the output pin.

The final piece of the puzzle is how the frequency of the square wave is determined. Since the timer ticks on every clock cycle, it will take 2*TOP cycles to cycle from BOTTOM to TOP and back. The AVR has a clock frequency of 16MHz and PWM_TOP in the TTS library is defined as 1200/2. This gives a frequency of about 13kHz.

By default PWM on Arduino/ESP8266 has a range of 1023 and frequency of 1kHz. However it provides APIs to change these values. By setting them appropriately, the ESP8266 speaks!

Wemos Mini D1 with TTS amplifier and super-cheap speaker
The picture shows a Wemos Mini D1 connected to a modified version of the simple LM386 amplifier described at the TTS GitHub. (The modifications arose from a Hackaday article on the LM386 and are summarised in the GitHub's README.)

This amplifier sounds surprisingly good, considering its total cost was about €1. Hooking it up to a signal generator and oscilloscope produced the following pretty pictures.

At low volume, the output is a pretty faithful inversion of the input signal (a 1kHz sine wave):

Undistorted Signal
At high volume, the output is clipped by the supply rails (but still sounds pretty good to my untrained ear):
Clipped Signal
These pictures were produced using an Xprotolab Plain, an amazing combination of Oscilloscope, Signal Generator and Protocol Analyzer implemented on an AVR XMEGA. Buy one!
Xprotolab Plain

Tuesday, 29 May 2018

ArduTouch

One of the very few downsides of ordering PCBs from Seeed Studio's Fusion service is the shipping cost. While an individual PCB can cost less than $0.50 in multiples of 10, shipping to Western Europe can add another $20.

One way to amortize these costs is to add more PCBs to an order, either from my own "design pipeline" or by searching online for cool projects. One very cool project discovered in this way, was ArduTouch from Cornfield Electronics.

One the hardware side, this is basically a battery-powered Arduino Uno with an LM386 amplifier driving a 4-Ohm mini-speaker, or your HiFi via line-in. The keypad is very nicely integrated into the PCB, see my construction below.
ArduTouch with Batteries and Cheap Speaker

Software-wise its GitHub provides five (at the last count!) different synthesizer sketches and a library for constructing your own. As usual, sketches are compiled in the Arduino IDE and uploaded by FTDI cable. A nice touch is that they uploaded a BOM for Mouser, making ordering the parts a snip!

I have several PCBs left over from this order. If you want one, contact me through the Tip Jar on the right. However I would encourage you to support the guys who made this great project possible by buying one of their kits.

Saturday, 13 January 2018

Web-Configured ESP8266

A unique feature of Internet-enabled "things" is that they often have an Internet connection and little else. First-configuration of these devices therefore presents a challenge, which most solve by creating their own wireless access point, to allow their owner to supply credentials for the local wireless network.

Web-Configured ESP is an attempt to abstract away the boilerplate required for this task, and other related ones. It's a "starter" sketch providing the following basic features:

  • Creation of a temporary Access Point ("MyESP") allowing the configuration at the conventional url, http://192.168.4.1
  • A basic web-server running at this address, serving config.json and storing updates to it
  • An HTTP update server, allowing upload of new sketches "over the air"
  • An mDNS responder allowing access at http://myesp.local
Together, these features allow bootstrapping of sketches without requiring the devices to be tethered to a development machine, and user-provisioning of the finished article in the field.

Wednesday, 8 November 2017

WifiWeatherGuy

My title will no doubt remind regular readers of 2013's Weather Guy, a weather app which completely maxed out an ATMega328. Well it's had a technology refresh replacing Ethernet with Wifi, XML with JSON and AVR with ESP. A surprising amount of display code survived the upgrade and can be found on GitHub (along with Eagle files and Gerbers).
WifiWeatherGuy

The hardware has also been simplified and now comprises merely:
The Wemos has been mounted on the underside of the board as can be seen above, because I soldered its pin headers on the wrong side; however this suggests to rotate the display by 180 degrees, making the build more compact.

The software is built on the following fine components:
Perhaps the most interesting aspect of this build is its configuration:
  • Stored in JSON format in the onboard flash filesystem
  • An index.html is served to a browser which loads the configuration file and initialises form input items (via Transparency)
  • Submission of the configuration form transmits the form values in JSON format to the server where it is stored back in the filesystem
  • The index page also supports firmware upgrade
This pattern, where the client assembles a UI for the user out of pieces obtained from the server is finally becoming prevalent in the wider web, but nowhere is it more useful than here where the client has maybe 200x the power of the serving microcontroller.

The Weather Underground API provides current conditions, a 5-day forecast and astronomical information. Two of these can be seen below.

Sunrise and Moon Phase



Current Weather Conditions