adc

92 Articles

Open Hardware Board For Robust USB Power Monitoring

December 11, 2018 by 9 Comments

We’ve all seen the little USB power meters that have become popular since nearly every portable device has adopted some variation of USB for charging. Placed between the power source and the device under test, they allow you to see voltage and current in real time. Perfect for determining how long you’ll be able to run a USB powered device on batteries, or finding out if a USB power supply has enough current to do the business.

[Jonas Persson] liked the idea of these cheap little gadgets, but wanted something a bit more scientific. His design, which he refers to as UPM, is essentially a “smart” version of those ubiquitous USB gadgets. Instead of just showing the data on a little LCD screen, it can now be viewed on the computer and analyzed. His little gadget even allows you to cut power to the device under test, potentially allowing for automated testing of things such as inrush current.

Essentially the UPM works in much the same way as the simple USB meters: one side of the device goes towards the upstream power source, and the device under test plugs into the other side. Between the two devices is a 16 bit ADC and differential amplifier which measures the voltage and current. There’s a header on the board which connects to the ADC if you wanted to connect the UPM to an external microcontroller or other data logging device.

But most likely you would be using the internal microcontroller to analyze the output of the ADC over I2C, which [Jonas] very cleverly connected to the upstream port with an integrated USB hub. One side of the hub goes off to the device being tested, and the other to the microcontroller. So the host device will see both the UPM’s integrated microcontroller and the target device at the same time. From there, you can use the ncurses user interface to monitor and control the device in real-time.

While the hardware looks more or less finished, [Jonas] has some more plans for the software side of UPM, including support for remote control and monitoring over TCP/IP as well as robust logging capabilities. This is definitely a very interesting project, and we’re excited to see it develop further.

In the past we’ve seen homebrew USB power meter builds, and even commercial offerings which boasted computer-based logging and analysis, so it was only a matter of time before somebody combined them into one.

An LED You Can Blow Out, With No Added Sensor

August 21, 2018 by 42 Comments

We’d seen it done with buttons, switches, gestures, capacitive touch, and IR remote, but never like this. [electron_plumber] made an LED that can be blown out like a candle, and amazingly it requires no added sensors. The project uses an Arduino to demonstrate turning a tiny LED on and off in response to being blown on, and the only components are the LED and a resistor.

[electron_plumber] used an 0402 LED and thin wires to maximize the temperature responses.
How is this done? [electron_plumber] uses an interesting property of diodes (which are the “D” in LED) to use the LED itself as a temperature sensor. A diode’s voltage drop depends on two things: the current that is being driven through the diode, and the temperature. If the current is held constant, then the forward voltage drop changes reliably in response to temperature. Turning the LED on warms it up and blowing on it cools it off, causing measurable changes in the voltage drop across the device. The change isn’t much — only a handful of millivolts — but the effect is consistent and can be measured. This is a principle [Elliot Williams] recently covered in depth: using diodes as temperature sensors.

It’s a clever demo with a two important details to make it work. The first is the LED itself; [electron_plumber] uses a tiny 0402 LED that is mounted on two wires in order to maximize the temperature change caused by blowing on it. The second is the method for detecting changes of only a few millivolts more reliably. By oversampling the Arduino’s ADC, an effectively higher resolution is obtained without adding any hardware or altering the voltage reference. Instead of reading the ADC once, the code reads the ADC 256 times and sums the readings. By working with the larger number, cumulative changes that would not register reliably on a single read can be captured and acted upon. More details are available from [electron_plumber]’s GitHub repository for LEDs as Sensors.

Embedded below is a video that is as wonderful as it is brief. It demonstrates the project in action, takes a “show, don’t tell” approach, and is no longer than it needs to be.

Continue reading “An LED You Can Blow Out, With No Added Sensor” →

Thumbs Up For This Custom Atari 5200 Controller

August 8, 2018 by 16 Comments

It may be nearly 40 years old, but the Atari 5200 still inspires legions of fans to relive the 8-bit glory days of their youth. There was much to love about the game console, but the joystick-and-keypad controllers were not among its many charms. The joystick didn’t auto-center, the buttons were mushy, and the ergonomics were nonexistent.

Retro-aficionados need not suffer in silence, though, thanks to this replacement controller for the Atari 5200. [Scott Baker] didn’t want to settle for one of the commercial replacements or, horrors, an adapter for the old PC-style joystick, so he rolled his own. Working from the original Atari schematics, [Scott] devised a plan for using a readily available thumbstick controller as the basis for his build. The essential problem was how to adapt the 10k pots on the new joystick to work in an environment expecting 500k pots, which he solved using an analog to digital and back to analog approach. The ADCs on an ATtiny85 convert each joystick pot’s voltage to a digital value between 0 and 255, which is sent to a 100K digital potentiometer. A little fiddling with RC constants brings it back in line with what the console expects. The thumbstick and buttons live on a custom PCB – kudos to [Scott] for designing an ambidextrous board. The video below shows the design and the finished product in action.

[Scott] is on a bit of a 5200 kick these days; he just finished up a Raspberry Pi multi-cartridge for the venerable console. His controller should make retro-gameplay on the console a little easier on the hands.

Continue reading “Thumbs Up For This Custom Atari 5200 Controller” →

Save Some Steps With This Arduino Rapid Design Board

July 28, 2018 by 18 Comments

We’re all familiar with the wide variety of Arduino development boards available these days, and we see project after project wired up on a Nano or an Uno. Not that there’s anything wrong with that, of course, but there comes a point where some hobbyists want to move beyond plugging wires into header sockets and build the microcontroller right into their project. That’s when one generally learns that development boards do a lot more than break the microcontroller lines out to headers, and that rolling your own design means including all that supporting circuitry.

To make that transition easier, [Sean Hodgins] has come up with a simple Arduino-compatible module that can be soldered right to a PCB. Dubbed the “HCC Mod” for the plated half-circle castellations that allows for easy soldering, the module is based on the Atmel SAMD21 microcontroller. With 16 GPIO lines, six ADCs, an onboard 3.3 V regulator, and a reset button, the module has everything needed to get started — just design a PCB with the right pad layout, solder it on, and surround it with your circuitry. Programming is done in the familiar Arduino IDE so you can get up and running quickly. [Sean] has a Kickstarter going for the modules, but he’s also releasing it as open source so you’re free to solder up your own like he does in the video below.

It’s certainly not the first dev module that can be directly soldered to a PCB, but we like the design and can see how it would simplify designs. [Sean] as shown us a lot of builds before, like this army of neural net robots, so he’ll no doubt put these modules to good use.

Continue reading “Save Some Steps With This Arduino Rapid Design Board” →

Double The Resolution, From An Arduino ADC

May 7, 2018 by 29 Comments

Analog-to-digital converters, or ADCs, are somewhat monolithic devices for most users, a black box that you ask nicely for the value on its input, and receive a number in return. For most readers, they will be built into whatever microcontroller is their platform of choice, and their resolution will be immutable, set by whatever circuitry is included upon the die. There are a few tricks that can be employed to get a bit more from a stock ADC though, and [Neris] has taken a look at a couple of them.

The first circuit doubles the resolution of an ADC, in this case, that of the Atmel chip in an Arduino, by converting its output from an integer to a signed integer. It performs this task with a precision rectifier, rectifying around a zero-crossing point half-way through the range of the analog value to be read and supplying a sign bit to the Arduino. The Arduino measures the rectified analog value to an integer, and applies the appropriate sign from the supplied bit value.

The second circuit takes a variation on the same technique but with two ADCs instead of one. A pair of PIC chips are used with their voltage references stacked one above the other, by taking both readings in combination a result with double the resolution can be derived.

You might ask why bother with these techniques. After all, there are plenty of higher-resolution ADCs on the market. But they’re useful techniques to know, should you ever need to extract the proverbial quart from a pint pot.

If ADCs are a mystery to you, you’re in luck. [Bil Herd] gave us a comprehensive introduction to the subject.

Portable DVD Player Gets Raspberry Pi Zero Upgrade

April 13, 2018 by 24 Comments

You might remember a time when people thought portable DVD players were a pretty neat idea. In the days before netbooks, cheap tablets, and arguably even the widespread adoption of smartphones, it seemed perfectly reasonable to lug around a device that did nothing but play movies. Today we look back at them as we would flip phones: a quaint precursor to the technology overload we find ourselves in currently. But the fact remains that millions of these comical little devices were pumped into the greedy maw of the consumer electronics market. They’re ripe for the hacking, all you need is some inspiration.

So if this grafting of a portable DVD player and the Raspberry Pi Zero W created by [nutsacrilege] doesn’t get you sniffing around your local second-hand store for a donor device, nothing will. By integrating a Pi running Kodi, the player gets a multi-media kick in the pants that arguably makes up for the rather archaic form factor. Not only can it play a wide array of local and online content, but it could even be used as portable game system if you were so inclined.

Rest assured, this isn’t some lazy five-minute mod. All of the original physical controls have been made functional by way of a MCP3008 ADC connected to the Pi’s GPIO and some clever Python scripting. Even the headphone jack was made functional by wiring it up to a USB sound card, and by integrating a tiny stripped down hub he was also able to add an external USB port. Who needs discs when you can plug in a flash drive full of content?

Speaking of which, [nutsacrilege] reports that the original functions of the device are still intact after all his modifications. So if you can get the museum to loan you one, you can even play a DVD on the thing as its creators intended.

With luck, this project will help spur on some more portable DVD player hacking, which we’ve seen precious little of so far. Frankly, it would be nice to see people cramming Raspberry Pi’s into something other than Game Boys for once.

[via /r/raspberry_pi]

A Compensated Thermocouple Amp, Ready For Arduino

March 15, 2018 by 14 Comments

When you want to measure temperature with an Arduino or other microcontrollers, there are a ton of options for sensors. Temperature chips and sensor modules abound, some with humidity sensors built-in and all with easy interfacing and an expansive supporting code library. But dip one of those sensors into, say, molten aluminum, and you’ve got a problem.

If you’re measuring something hot, you need a thermocouple. Trouble is, the signal from a thermocouple is pretty small, and needs amplification and compensation before being fed into the ADC of a typical microcontroller. Unable to find a commercial amp to meet his needs, [MonkHelios] built his own thermocouple amp for microcontrollers. The design is centered around an LTC2053 instrumentation amp, which does the job of converting the K-type thermocouple’s 40.6μV/°C output to a nicely scaled 10mV/°C range, just right for ADC consumption. He also thoughtfully included an LT1025 cold-junction compensator; thermocouple amps are referenced to 0°C, so the compensator measures the actual temperature of the cold end of the junction and scales the output accordingly. The whole amp is nicely laid out on a DIY single-sided PCB with meticulously applied solder mask — this is one of the nicest home-etched boards we’ve seen in a long time.

[Bil Herd] designed a similar thermocouple amp not too long ago himself, so you might check that out too.  Or maybe you need the basics of instrumentation amps? Our “Beyond Measure” series will get you started.