hardware

1822 Articles

Testing 30 Brands Of Batteries

September 14, 2012 by 46 Comments

Batteries come packaged in bright blister packs emblazoned with vague guarantees such as “45% more pictures” and “five times longer lasting.” During his internship at BitBox this summer, [Thomas] decided to put those statements to the test. He tested thirty brands of batteries on a homebrew rig to find the batteries with the most power and the most bang for your buck.

The hardware [Thomas] used an STM32 microcontroller to perform two different tests: a high drain and a low drain condition. For the high drain, 1000 mA were sucked out of the batteries until the voltage reached 0.8 V. For the low drain, 200 mA were used. Data including milliwatt-hours, milliamp-hours, joules, voltage, current, power, and effective load resistance were all logged for both conditions for all 30 batteries.

Generalizing the results for both low and high drain conditions, lithium batteries were better than alkaline, which were both better than zinc AA cells. Perhaps unsurprisingly, batteries marketed as ‘long life’ and ‘extended power’ were the worst batteries for the money, but a brand-name battery – the Kodak Xtralife cells – were actually the best value for the money.

Generating Random Numbers From White Noise

September 12, 2012 by 22 Comments

Even though rand() may be a good enough random number generator for making a video game, the patterns of random bits it spits out may not be sufficient for applications requiring truly random data. [Giorgio] built his own random number generator, and after many statistical tests it ended up being random enough for a few very complex calculations.

Previously, we saw [Giorgio] generate random numbers with a Chua circuit, but for all the complexity of building an electronic strange attractor there’s actually a much simpler source of random data: a white noise generator.

[Giorgio]’s random number generator for this project is just a pair of resistors, with an op-amp buffer, amplifier, and current switch to turn analog data into a digital output of random 1s and 0s. [Giorgio] sampled this data by plugging the digital out into one of the GPIO pins of a Raspberry Pi and recording the data with s small script.

To verify his sequence of bits was actually random, [Giorgio] performed a few tests on the data, some more reliable in determining randomness than others.

Because every project needs a few awesome visualizations, [Giorgio] plotted each sequence of bits as either a black or white pixel in a bitmap. The resulting image certainly looks like television static, so there are no obvious problems with the data.

[Giorgio] also performed an interesting Monte Carlo simulation with his megabytes of random data: By plotting points on a plane (with a range from 0,0 to 1,1), [Giorgio] can approximate the value of π by testing if a point is inside a circle with a radius of 1. The best approximation of pi using 10,000 points of random data came out to be 3.1436

Of course [Giorgio] put his random data through a few proper statistical tests such as rngtest and dieharder, passing all the tests of randomness with flying colors. An interesting build that shows a small glimpse of how hard generating really random numbers actually is.

Bed Of Nails And Accuracy In PCB Manufacturing

September 11, 2012 by 43 Comments

A few days ago, we mentioned the new ARM-powered Teensy 3.0 project on Kickstarter. The creator, [Paul Stoffregen], decided to share the trials of building a test fixture along with a shocking comparison of the accuracy of different PCB manufacturers in an update to his Kickstarter.

Because [Paul]’s Teensy 3.0 has more IO pins than should be possible on such a small board, the test fixture to verify if a board is defective or not is fairly complex. To test each board, a Teensy is placed on dozens of spring-loaded contacts arranged like a bed of nails. From there, another Teensy (this time a Teensy 2.0) performs a few tests by cycling through all the pins with several patterns.

Because the spring-loaded contacts require rather precise drill holes in the PCB of his test fixture, [Paul] thought it would be neat to compare the accuracy of several board houses. In the title pic for this post (click to embiggen), [Paul] demonstrates the capabilities of OSH Park, Seeed Studio, and iTead Studio. The lesson here is probably going with a US company if quality drill work is a necessary requirement of your next project.

Put A Solder Mask On Those Homebrew PCBs

September 10, 2012 by 19 Comments

While making your own PCBs at home is one of the best marks of a competent builder, if you want to give your project a more professional vibe, you’re going to need to do better than bare copper traces on a piece of fiberglass. To help out his fellow makers, [Chris] sent in his Instructable on creating a solder mask for homemade circuit boards using a minimal amount of tools and materials easily sourced from the Internet.

[Chris]’ soldermasks are made from UV curing paints he found on eBay. Of course the traditional green paint is available, along with paints very similar to the Sparkfun red or Arduino blue soldermasks.

After brushing the soldermask paint onto his home-etched circuit board, [Chris] printed out the solder mask onto a piece of transparency film using a laser printer. This mask is vitally important if you ever plan to solder your board; by covering the pads you wish to solder, the paint won’t cure and can later be removed.

[Chris] cured his soldermask by leaving it in the sun for a half hour. After the paint was dry, he removed the excess paint covering the pads with a little bit of turpentine and some elbow grease.

While [Chris]’ paint had somewhat of an ugly matte finish, the soldermask does its job, protecting the PCB traces while leaving the pads uncovered and ready to solder.

Mess Of Wires Is Actually A One Instruction Computer

September 5, 2012 by 21 Comments

If you’re going to build your own computer, it probably wouldn’t do you well to exactly emulate the computer you’re looking at right now. The modern x86 and x64 chips that power your desktop or laptop contain hundreds of individual instructions, and the supposed RISC CPUs found in ARM-powered devices contain nearly as many. No, if you’re going to build your own computer you should make it easy on yourself, just as [Jack Eisenmann] did  when he built the DUO Compact, a one-instruction set computer made on a breadboard.

Instead of dozens or hundreds of individual instructions, a one instruction computer has – like its name implies – only one way of manipulating bits. For the DUO Compact, [Jack] chose a NOR and fork conditionally instruction. Each line of assembly written for the DUO Compact has four memory instructions: a source address, destination address, skip address 1, and skip address 2. [Jack] explains exactly how this operation can allow him to compute everything:

Three steps occur when executing the instruction:

  1. Load the byte at the first and second address. NOR these bytes together.
  2. Store the result of step 1 in the second address.
  3. If the result of step 1 was zero, then skip to the instruction at the fourth address; otherwise, skip to the instruction at the third address.

As if designing a one instruction computer built using only basic logic and memory chips wasn’t impressive enough, [Jack] went as far as writing an emulator for his system, a compiler, an operating system, and even a few programs such as a square root calculator and a text-based adventure game.

By any measure, [Jack] has finished an amazing build, but we’re blown away by the sheer amount of documentation he’s made available. He’s even gone so far as to write a tutorial for building your own DUO Compact.

You can check out a few videos of the DUO Compact after the break. Of course, if you’re looking for a project to tackle, you’re more than welcome to design a PCB from the DUO Compact schematic. We’d certainly buy one.

Continue reading “Mess Of Wires Is Actually A One Instruction Computer” →

Open Source Brushless Motor Controller

September 4, 2012 by 29 Comments

It’s been a long time coming, but efforts to create Open Source brushless motor controller are finally paying off.

The Open-BLDC project aims to create an open source motor controller for the brushless motors usually found in remote control airplanes, helicopters, and quadcopters. Normally, these motor controllers – usually called electronic speed controllers – can’t supply more than a few dozen amps, and are usually only controllable via a servo signal.

The Open-BLDC goes far beyond the capabilities of off-the-shelf ESCs with up to 200 amps of output, TTL level serial input, and the ability to use regenerative breaking.

While the Open-BLDC project is far from complete, the team working on the hardware hopes to add I2C, CAN, and PPM interfaces, along with speed and torque control.

There is no word on when, or even if, the Open-BLDC will ever be available for sale, but with the features it has it would be welcomed by just about any builder constructing a gigantic RC vehicle.

Displaying Images On The Surface Of Bubbles

September 3, 2012 by 13 Comments

The image you see above isn’t a simple photograph of our blue marble from thousands of miles above. No, that image is much cooler than a satellite because it’s a projection of the Earth onto a soap film screen. Yes, we can now display images on the surface of bubbles.

Instead of a the soap bubbles you’d normally give a small child, this project uses a mixture of sugar, glycerin, soap, surfactant, water, and milk to produce a film much more resistant to popping than your standard soap bubble. Shining an image through these films doesn’t result in much of an image, so the researchers used ultrasonic speakers to vibrate the film and make it possible to display a picture.

With a small projector, this system makes it possible to display an image on the surface of bubble. Of course, the display area is tiny right now, but the size will most likely increase as the experimentations continue.

You can check out a whole bunch of videos demoing this tech after the break.

Continue reading “Displaying Images On The Surface Of Bubbles” →