AVR Microcontroller Doubles Up As A Switching Regulator

[SM6VFZ] designed, built and tested a switched-mode DC-DC boost regulator using the core independent peripherals (CIP) of an ATtiny214 micro-controller as a proof of concept, and it looks pretty promising!

A Buck, Boost, or Buck-Boost switching regulator topology usually consists of a diode, a switching element (MOSFET) and an energy storage device (inductor/capacitor) in the power path, and a controller that can measure the output voltage, control the switching element and add safety features such as current limiting and temperature shutdown. A search for switching regulators or controllers throws up thousands of parts, and it’s possible to select one specifically well suited for any desired application. Even so, the ability to use the micro-controller itself as the regulator can have several use cases. Such an implementation allows for a software configurable switch-mode regulator and easy topology changes (boost, buck, fly back etc.).

The “Getting Started with Core Independent Peripherals on AVR®” application note is a good place to get an overview of how the CIP functionality works. Configurable Custom Logic (CCL) is among one of the powerful CIP peripherals. Think of CCL as a rudimentary CPLD — a programmable logic peripheral, which can be connected to a wide range of internal and external inputs such as device pins, events, or other internal peripherals. The CCL can serve as “glue logic” between the device peripherals and external devices. The CCL peripheral offers two LookUp Tables (LUT). Each LUT consists of three inputs, a truth table, a synchronizer, a filter, and an edge detector. Each LUT can generate an output as a user programmable logic expression with three inputs and any device that have CCL peripherals will have a minimum of two LUTs available.

This napkinCAD sketch shows how [SM6VFZ] implemented the boost regulator in the ATtiny214. The AND gate is formed using one of the CCL LUT’s. The first “timer 1” on the left, connected to one input of the AND gate, is free running and set at 33 kHz. The analog comparator compares the boosted output voltage against an internally generated reference voltage derived from the DAC. The output of the comparator then “gates” timer 1 signal to trigger the second “timer 2” — which is a mono-shot timer set to max out at 15 us. This makes sure there is enough time left for the inductor to completely release its energy before the next cycle starts. You can check out the code that [SM6VFZ] used to built this prototype, and his generous amounts of commenting makes it easy to figure out how it works.

Based on this design, the prototype that he built delivers 12 V at about 200 mA with an 85% efficiency, which compares pretty well against regular switching regulators. Keep in mind that this is more of a proof-of-concept (that actually works), and there is a lot of scope for improvement in terms of noise, efficiency and other parameters, so everyone’s comments are welcome.

In an earlier blog post, we looked at how ATmegas with Programmable Logic came about with this feature that is usually found in PIC micro-controllers, thanks to Microchip’s acquisition of Atmel a few years back. But we haven’t seen any practical example of the CCL peripheral in an Atmel chip up until now.

Improve ATtiny Timing Accuracy With This Clock Calibrator

The smaller ATtiny microcontrollers have a limited number of pins, and therefore rely on an internal 9.6 MHz oscillator rather than an external crystal. This oscillator lacks the accuracy of a crystal so individual chips can vary over a significant tolerance from the nominal figure. Happily the resulting timing inaccuracies can be mitigated through a calibration process, and [Stefan Wagner] has incorporated this into his Tiny Calibrator. In addition, it also has the required charge pump circuitry to reset the internal fuses to rescue “bricked” ATtinys, thus allowing those little mistakes to be salvaged.

The board has its own larger ATtiny with a crystal oscillator and an OLED screen, allowing it to measure that of the test ATtiny and generate a correction factor which it applies to the chip. This process is repeated until there is the smallest possible difference from the standard. You can find the files for the hardware on EasyEDA, and the software in a GitHub repository.

It’s important to state that the result will never be as stable as a crystal so you’d be well advised not to put too much trust in those timers, but at least they won’t be as far off the mark as when shipped. All in all this is a handy board to have at hand should you be developing for the smaller ATtiny chips.

Be careful when chasing clock accuracy — it can lead you down a rabbit hole.

A Tiny LED Matrix Is Better With Friends

When we last heard from [lixielabs] he was building Nixie tube replacements out of etched acrylic and LEDs. Well he’s moved forward a few decades to bring us the Pixie, a chainable, addressable backpack for tiny LED matrix displays.

Each Pixie module is designed to host two gorgeous little Lite-On LTP-305G/HR 5×7 LED dot matrix displays, which we suspect have been impulse purchases in many a shopping cart. Along with the displays there is a small matrix controller and an ATTINY45 to expose a friendly electrical interface. Each module is designed to be mounted edge to edge and daisy chained out to 12 or more (with two displays each) for a flexible display any size you need. But to address the entire array only two control pins are required (data and clock).

[lixielabs] has done the legwork to make using those pins as easy as possible. He is careful to point out the importance of a good SDK and provides handy Arduino libraries for common microcontrollers and a reference implementation for the Raspberry Pi that should be easy to crib from to support new platforms. To go with that library support is superb documentation in the form of a datasheet (complete with dimensions and schematic!) and well stocked GitHub repo with examples and more.

To get a sense of their graphical capabilities, check out a video of 6 Pixie’s acting as a VU meter after the break. The Pixie looks like what you get when a hacker gets frustrated at reinventing LED dot matrix control for every project and decided to solve it once and for all. The design is clean, well documented, and extremely functional. We’re excited to see what comes next! Continue reading “A Tiny LED Matrix Is Better With Friends”

TinyTacho: Rotational Speed Measurement Without The Bulk

An electronic tachometer is a straightforward enough device, in which the light reflections from a white spot on a rotating object are detected and counted over time, measuring the revolutions per minute (RPM). It’s a technique that has its roots in analogue electronics where the resulting pulses would have fed a charge pump, and it’s a task well suited to a microcontroller that simply counts them. But do you need an all-singing, all-dancing chip to do the job? [Stefan Wagner] has done it with a humble ATtiny13.

His TinyTacho is a small PCB with an IR LED and photodiode on one end, a small OLED display on its front, and a coin cell holder on its rear. The electronics may be extremely simple, but there’s still quite some effort to get it within the ATtiny’s meagre resources. Counting the revolutions is easy enough, but the chip has no I2C interface of its own and some bitbanging code is required. You can find all the design files and software you need in a GitHub repository, and he’s put up a video of the device in action that you can see below the break.

Tachometers are a popular project hereabouts, and we’ve featured a lot of them over the years. Perhaps the best place to direct readers then is not to another project, but to how to use a tachometer.

Continue reading “TinyTacho: Rotational Speed Measurement Without The Bulk”

The Mystery Of A Particular ATtiny85 Fuse

First-timers playing with 8-bit micros such as the AVR and PIC will at some point in their lives, find themselves locked out of their MCUs. This is usually attributed to badly configured fuses that disable certain IO functions rending the device unprogrammable via conventional ICSP methods. [Uri Shaked] shares his story of how his ATtiny85 got locked and became the subject of a lengthy investigation into fuse bit configurations.

[Uri]’s journey started when he accidentally left some pins of the device connected to a second board while he was flashing the firmware. He quickly researched online for a solution for the problem and it turns out, there are a number of recipes to resolve the issue. As it turns out, his problem was not so straight-forward and warranted more digging. [Uri] ended setting up a High Voltage Programming serial programming setup and then probing the communications. He discovered that the chip refused to reset its fuses and would reject attempts to set fuses.

Further investigation of the fuse bits and reading them proved useful in understanding that the memory protection features were preventing alteration of the device. The quick-fix was to erase the ATtiny and things were back to normal thereafter. [Uri] details his pursuit of reading and comparing fuse bits from the impacted chip against a fresh device which is where he makes the discovery. The write-up is a case study in the investigation into the idiosyncrasies of device programming and will be a great resource for many and reduce hair loss for some.

Once you get your hands on an ATTINY, there are a number of small experiments to be done to cure boredom. Be sure to share your experiments and stories with us to inspire the masses.

Motorized Magic Over HDMI

There is a certain warmth that seems to emanate from stereo receivers of the 70s, 80s, and 90s. Despite their large footprint and considerable heft, the soft glow of the indicator lights and solid kerthunk of switches provide a sense of coziness. When [Tom] recently swapped his receiver for a 1970s Pioneer SX-950, he found himself getting up from the couch to adjust the volume when watching TV far too often for his liking. Resolving to do something about it, he added some magic in the form of a motorized volume knob. One of the coolest tricks for stereos was to have a small motor attached to the volume knob so that it could turn the volume up or down via a remote.

The first obstacle came when [Tom] had to forgo the center tap on the potentiometer to get a motorized one. This meant the volume compensation feature would be disabled, which is but a small price to pay for convenience. After scouring the internet, he finally had the part in hand only to discover some troublesome capacitors in the way. The new pot had a rather large motor hanging off the back that the previous one didn’t have. Fortunately, there was a good bit of space between the PCB and the bottom of the chassis, so Tom was able to just flip the capacitors to the underside of the board and bend them on their sides.

The next problem to solve was how to change the volume remotely. IR was considered as well as optical cable control signals. What [Tom] did instead was to implement HDMI CEC (consumer electronics control). CEC was well documented and seemed simple to implement on an ATTINY4313 with the help of a half-H driver. The CEC protocol implemented by [Tom’s] TV seemed to be very sensitive to timing, so an external crystal was used to get more precise timing and additional handshaking was implemented to get the TV to accept the microcontroller as valid. A few fail-safes were added to make sure the motor didn’t burn out if something went wrong with the CEC protocol and a nice enclosure wrapped up the build quite nicely.

We’ve seen CEC implemented before on a PIC 18F87J50, but as a sender of CEC commands not a receiver. [Tom’s] code is available on GitHub and might prove useful if you’re looking to implement CEC on an AVR.

Thanks [Tom] for sending this one in!

Tiny Mario Clone On A Tiny Processor

We’ve become used to seeing retro games running on commodity microcontrollers where once they would have required the bleeding-edge console hardware of their day. [Duncan]’s Mario clone takes the genre a little further, using not a processor with plenty of pins for peripherals, but instead the humble ATtiny85. Its eight pins drive two OLED displays, and accept input from the buttons of a cheap Nintendo-like controller.

The write-up is split between software and hardware sections, with all the software itself available from a GitHub repository. He’s bit-banging the i2C for the displays for an impressive turn of speed, and the ATtiny’s lack of pins is addressed by clever use of resistive dividers to present a different voltage for each button pressed. With a truth table of voltages he’s even able to detect multiple simultaneous button presses. Music is achieved with the chip’s limited resources by storing the sounds in EEPROM, and clocked it at 16 MHz for smooth gameplay.

The whole is mounted inside the shell of the controller, with its USB guts removed and replaced by a smart custom PCB. An unexpected problem with ground plane fill caused a temporary roadblock reading the buttons, but the finished product is a very Nintendo-like experience. We like it.