Class D Amp with an H-Bridge

Class D amps are simple – just take an input, and use that to modulate a square wave with PWM. Send this PWM signal to a MOSFET or something, and you have the simplest class D amp in existence. They’re so simple, you can buy a class D amp chip for $3, but [George] thought that would be too easy. Instead, he built his own with an ATTiny and an H-bridge motor driver. No surprise, it works, but what’s interesting is what effect the code on the ATtiny can have on the quality of the audio coming out of the speaker.

The microcontroller chosen for this project was the ATtiny 461, a part we don’t see much, but still exactly what you’d expect from an ATtiny. The heavy lifting part of this build is an L298 chip found on eBay for a few dollars. This dual H-bridge is usually used for driving motors, but [George] found a home for it in the power section of an amplifier.

The ATtiny is clocked at 16 MHz, making the ADC clock run at 1 MHz. A 10-bit precision conversion takes place, and this value sets the PWM duty cycle. Timer1 in the chip is set up to run at 32 MHz, and by counting this timer up to 1023 gives this amp its PWM cycle speed of 31.25 kHz. That’s right in the neighborhood of what a class D amp should run at, and the code is only about 30 lines. It can’t get simpler than that.

[George] put up a video of this amp in operation, and despite not following the standard design of a Class D amp, it sounds pretty good. You can see that video below.

Continue reading “Class D Amp with an H-Bridge”

3D-Printed Clock Tells Time with Gears

[ekaggrat] designed a 3d-printed clock that’s fairly simple to make and looks awesome. The clock features a series of 3d-printed gears, all driven by a single stepper motor that [ekaggrat] found in surplus.

The clock’s controller is based around an ATtiny2313 programmed with the Arduino IDE. The ATtiny controls a Darlington driver IC which is used to run the stepper motor. The ATtiny drives the stepper motor forward every minute, which moves both the hour and minute hands through the 3d-printed gears. The hour and minute are indicated by two orange posts inside the large gears.

[ekaggrat] etched his own PCB for the microcontroller and stepper driver, making the build nice and compact. If you want to build your own, [ekaggrat] posted all of his design files on GitHub. All you need is a PCB (or breadboard), a few components,  and a bit of time on a 3D printer to make your own clock.

Measuring the Length of WS2812 Strips

[Tim] discovered a simple way to measure the length of WS2812 addressable LED strips from a microcontroller. This is great for any project that can have an arbitrary length of addressable LED strip attached to it.

The simplest (and perhaps most reliable) way to measure strip length is by feeding the serial output pin of the end of the strip back to the microcontroller. The microcontroller keeps clocking bits into the strip until it receives data from the end of the strip. [Tim] didn’t want to run an additional signal to the end of his strip, so he found another solution.

[Tim] used the ADC of his microcontroller (an ATtiny) to measure supply voltage droop as LEDs are turned on. Each LED draws around 60mA at full brightness, so [Tim] sequentially turned on each LED and watched the ADC for slight voltage changes. If the voltage changed, there must be an LED at that address. [Tim] does note that this method is extremely dependent on the power supply used and only works on short strips. Check out his blog post for more details.

Adding a Battery Gauge to a Project With Zero Parts

The typical way of doing a low battery detector is throwing a comparator in the circuit, setting it to measure a certain threshold voltage, and sending that signal off to a microcontroller or other circuit to notify someone the battery is going dead. [Josh] has a simpler way using an 8-bit AVR and zero other parts.

The chip [Josh] is using is the ATtiny84. The ADC in this chip is usually used to measure an unknown voltage against a reference voltage. The trick [Josh] is using is to do this in reverse: The internal 1.1 Volt reference voltage is measured against an unknown scale, namely the input voltage.

The value provided by the ADC on the chip will always be Vin times 1024 over the reference voltage. Since Vin will be 1.1 V in this case, the ADC value is known, it’s only a matter of doing some 6th grade algebra to determine the value of the input voltage.

[Josh] put together a small demonstration where the chip blinks out the number of volts its receiving from a bench power supply. By blinking a LED, it can blink out the current value of VCC as integers, but by using this technique you should be able to get a fairly fine-grained reading of what VCC actually is. Video below.

Continue reading “Adding a Battery Gauge to a Project With Zero Parts”

Inexpensive AVR Programmer Made From Five Components

If you want to program an AVR chip as inexpensively as possible, then [Ian’s] solution might just be for you. He built an AVR programmer using only four components. This design is based on the vusbtiny AVR programmer design, with a few components left out.

[Ian’s] design leaves out two of the resistors and two diodes, leaving just four components. These include a 1.5k resistor, a small capacitor, a USB connector, a six pin header, and an ATtiny45. He admits that this may not be exactly up to USB spec, but it does work.

This is one of those projects that is really an exercise in “will it work?” more than anything else. The fact that you need to first program an AVR chip means that this wouldn’t be useful in a pinch, because you would already have to have a working programmer. Nonetheless, it’s always fun to see what can be done with as little as possible.

Now Let’s See The World’s Largest Arduino

A few days ago we saw what would have been a killer Kickstarter a few years ago. It was the smallest conceivable ATtiny85 microcontroller board, with resistors, diodes, a USB connector, and eight pins for plugging into a breadboard. It’s a shame this design wasn’t around for the great Arduino Minification of Kickstarter in late 2011; it would have easily netted a few hundred thousand dollars, a TED talk, and a TechCrunch biopic.

[AtomSoftTech] has thrown his gauntlet down and created an even smaller ‘tiny85 board. it measures 0.4in by 0.3in, including the passives, reset switch, and USB connector. To put that in perspective, the PDIP package of the ‘tiny85 measures 0.4 x 0.4. How is [Atom] getting away with this? Cheating, splitting the circuit onto two stacked boards, or knowing the right components, depending on how you look at it.

USB [Atom] is using a few interesting components in this build. The USB connector is a surface mount vertical part, making the USB cord stick out the top of this uC board. The reset button is extremely small as well, sticking out of the interior layer of the PCB sandwich.

[AtomSoft] has the project up on OSH Park ($1.55 for three. How cool is that?), and we assume he’ll be selling the official World’s Smallest Arduino-compatible board at Tindie in time.

What Is This, A Microcontroller Board For Ants?

You youngins probably don’t remember this, but a few years ago there was an arms race on Kickstarter to create the smallest Arduino-compatible microcontroller board. Since then, a few people have realized they can make more money on Kickstarter through fraud or potato salad, and the race to create the smallest ‘duino board petered out.

It’s a shame [Meizhu] wasn’t part of the great miniature Arduinofication of Kickstarter, because this project would have won. It’s an Atmel ATtiny85, with USB port, resistors, diodes, reset button, LED, and pin headers, that is just 72 mils larger than the PDIP package of the ‘tiny85. Outside of getting a bare die of ‘tiny85s, there isn’t much of a chance of this board becoming any smaller.

[Meizhu] was inspired to create this board from [Tim]’s Nanite 85, which up until a few days ago was the current champion of micro microcontroller boards. With a bit of work in KiCAD, the new board layout was created that is just a hair larger than the 0.4″ x 0.4″ footprint of the PDIP ATtiny85. There were a few challenges in getting a working board this small; you’d be surprised how large the plastic bits around pin headers are, but with some very crafty soldering, [Meizhu] was able to get it to work.