Toorcamp: Bliplace 2.0

August 15, 2012 by Eric Evenchick 7 Comments

We’ve shown [Tanjent]’s Bliplace 1.0 in the past. He handed out a few hundred of the open source audio toys at Burning Man. At Toorcamp, he’s been showing off an improved 2.0 version of the project. This one has a more powerful microcontroller and many more RGB LEDs.

The device uses the ATMega328 and an electret microphone to sample ambient noise. It the processes the sound into a light pattern which is displayed on the line of RGB LEDs. The demo that I saw showed the LEDs synchronized to bass frequencies, which it could pick up at a range from the large sub-woofers at Toorcamp. It’s powered by a CR2032 coin cell battery, which means it can be worn as a neat audio toy.

This prototype version was etched in his kitchen but [Tanjent] is working on making a production version of the PCB. He plans to release it as a surface mount soldering kit.

A Detailed Tutorial On Speeding Up AVR Division

July 15, 2012 by Brian Benchoff 32 Comments

[Alan Burlison] is working on an Arduino project with an accelerometer and a few LEDs. Having the LEDs light up as his board is tilted to one side or another is an easy enough project a computer cowboy could whip out in an hour, but [Alan] – ever the perfectionist – decided to optimize his code so his accelerometer-controlled LEDs don’t jitter. The result is a spectacular blog post chronicling the pitfalls of floating point math and division on an AVR.

To remove the jitter from his LEDs, [Alan] used a smoothing algorithm known as an exponential moving average. This algorithm uses multiplication and is usually implemented using floating point arithmetic. Unfortunately, AVRs don’t have floating point arithmetic so [Alan] used fixed point arithmetic – a system similar to balancing your checkbook in cents rather than dollars.

With a clever use of bit shifting to calculate the average with scaling, [Alan] was able to make the fixed point version nearly six times faster than the floating point algorithm implementation. After digging into the assembly of his fixed point algorithm, he was able to speed it up to 10 times faster than floating point arithmetic.

The takeaway from [Alan]’s adventures in arithmetic is that division on an AVR is slow. Not very surprising after you realize the AVR doesn’t have a division instruction. Of course, sometimes you can’t get around having to divide so multiplying by the reciprocal and using fixed point arithmetic is the way to go if speed is an issue.

Sure, squeezing every last cycle out of an 8 bit microcontroller is a bit excessive if you’re just using an Arduino as a switch. If you’re doing something with graphics or need very fast response times, [Alan] gives a lot of really useful tips.

The Effect Of Code On Power Consumption

June 14, 2012 by Brian Benchoff 36 Comments

Of course putting a microcontroller into sleep mode or changing the clock rate has an effect on the power consumption of the chip, but what about different bits of code? Is multiplying two numbers more efficient than adding them, and does ORing two values consume more power than NOPping? [jcw] wanted to compare the power draw of a microcontroller running different loops, so he threw some code on a JeeNode and hooked it up to an oscilloscope.

For his test, [jcw] tested two instructions: multiply and shift left. These loops run 50,000 and 5,000 times, respectively (bit shifting is really slow on ATMegas, apparently) and looked at the oscilloscope as the JeeNode was doing its work.

Surprisingly, there is a difference in power consumption between the multiply and shift loops. The shift loop draws 8.4 mA, while the multiply loop draws 8.8 mA. Not much, but clearly visible and measurable. While you’re probably not going to optimize the power draw of a project by only using low-power instructions, it’s still very interesting to watch a microcontroller do its thing.

ATtiny85 Sketch Flashing Rig

May 31, 2012 by Mike Szczys 9 Comments

We’re happy to see Arduino enthusiasts championing the use of smaller hardware when the need for a full-blown ATmega-based board just isn’t there. [Chris] has been doing just that, using ATtiny85 chips in his projects. But he’s tired of hooking jumper wires to flash the sketches. He finally got around to etching this ATtiny85 programming adapter.

If the project is not pin hungry, an ATtiny85 can run Arduino sketches without the need to port the code. The best news is that the Arduino board you used to prototype the project can be used as the programmer for the standalone chip. Here that’s a Boarduino, and [Chris] laid out a double row of female pin headers for quick plug-in. To the right you can see the DIP socket for the target chip. Although this works perfectly well, we would have liked to also see the inclusion of a 2×3 AVR ISP programming header which could be used with the full range of AT chips.

One Wire Reads The Keypad From The APRS Radio Mic

May 9, 2012 by Mike Szczys 3 Comments

[Shane Burrell] decided to spend some time learning how the keypad on the his Kenwood TM-710A APRS radio mic works. It uses a different technique than you might think. Normally a grid of buttons is scanned as a matrix to detect keypresses, but this hardware actually counts pulses on a serial wire to take each reading.

The stock radio sends a steady digital pulse to the handset and with each pulse the mic pulls the line low. It then uses a 4017 decade counter to see what comes back. If the edge count matches it means nothing is pressed, but a change in the number of pulses returning to the base unit can be used to extrapolate which button has been pressed.

[Shane] went on to implement this control technique using an AVR chip in place of the radio base unit. He used the data gained from measuring the pulse behavior using an oscilloscope to write the firmware for the project. He filmed a bit of a demo after the break which shows his findings.

We’re not quite sure how this would translate into your own home-brew projects, but the thought of scanning a keypad with two pins of a uC is quite desirable. Sure there is the 555-timer frequency technique, but we’re always down with new ideas.

Continue reading “One Wire Reads The Keypad From The APRS Radio Mic” →

TI Launchpad As AVR ISP Programmer

May 3, 2012 by Mike Szczys 8 Comments

[Minifloat] is using his TI Launchpad development board as an In-System Programmer for AVR chips (translated). There are a ton of homebrew AVR programmers out there, and using an Arduino for ISP is quite popular. But recently we searched for a way to use the Launchpad as a programmer and didn’t find one. We’d venture to say this is the first.

There is one hardware modification that must be made. An external clock crystal (32.768 kHz) must be populated on the board. But since it was designed with the feature in mind that’s a pretty quick process. [Minifloat] followed Atmel’s ISP app note, and extended some of the code written for a different programmer to get things up and running. At first the device wouldn’t communicate with AVRdude, but that turns out to be a problem with the initialization conversation. AVRdude polls the connected programmer to see if it supports block mode, and the firmware on the MSP430G2211 wasn’t expecting this query. The problem was fixed and it now works.

It sounds like there are a couple of bugs left in the system. The first time AVRdude accesses the programmer after it has been plugged into the USB port it will fail. Subsequent attempts will succeed until the MSP430 chip is reset, or the USB connection is replugged. But if you’re just getting into the AVR line, this will let you figure out if you want to invest in a proper programmer.

BASIC For Some Beefy AVR chips

May 3, 2012 by Mike Szczys 10 Comments

klBASIC is a BASIC interpreter written in C for AVR microcontrollers. [Karl Lunt] developed the project based on an assembly language BASIC interpreter for 68HC11 chips written by [Gordon Doughman]. The transition from assembly to C bulked up the code, so you’ll need a beefy AVR chip in order to store all of it.

The idea is that one AVR chip can run BASIC with just a serial monitor. But like this Arduino BASIC interpreter build, it would be a snap to run this with a keyboard and small LCD screen. We see binaries available for several different AVR devices including ATmega128, ATmega1284, and Xmega128. They range from 1.5k to 16k of program memory. We didn’t find a link to the source code (just these precompiled files) so we inquired with [Karl] to see if that is available. He’s reluctant to release the code because it’s “pretty much a mess” and doesn’t live up to his normal standards. If he codes for a living we can see how that may be embarrassing. If you’d like to lend a hand cleaning up the code, let him know by leaving a comment here and maybe he’ll release it for that purpose.

We find this interesting, but it’s tough to get excited about building one of our own. If this has inspired you, we’d love to hear some of your plans in the comments after the break. Perhaps we’d be prodded into another programming adventure based on your enthusiasm.