New STM32 Discovery Board Can Now Be Programmed On Linux

June 4, 2012 by Mike Szczys 12 Comments

Last Wednesday I posted a video review of the new STM32F0-Discovery board which is built around an ARM Cortex-M0 chip. I speculated that it should work with the open source project aimed at programming these discovery boards. I tested it out and a connection could be made, but no code could be flashed. So I spent a few hours over the weekend and added support.

My updates are already in the stlink repository. After cloning the code, you can use three commands to compile the software (./autogen.sh, ./configure, make). That’s assuming you have all of the necessary dependencies (I had to install libusb-1.0-0-dev) and that you add the udev rule suggested in the documentation (also found in the repository). The program st-util connects to the board and provides a listening port for an ARM debugger (I’m using arm-none-eabi-gdb from CodeSourcery G++ Lite).

When I first started testing, the chip id was reporting as 0. It turns out the register address polled for this information was wrong. After finding that in the almost-900 page reference manual I went through the painstaking process of finding the hex values necessary to properly memory map the device. From there I also updated the blink example to generate an ELF file compatible with the Cortex-M0 chip. So out of the gate you should be able to use an ARM cross compiling toolchain to compile the example, connect to the board with this utility, then use the debugger from the toolchain to connect and flash that example to RAM.

There’s lots more to be done. To fully utilize the chip it is necessary to use a startup file and linker script when compiling. I’ve done nothing in this area, but I hope to work on some tutorials as I get further along. Of course if you have your own successes developing for this board using a Linux machine we want to hear about it!

Data Logging Directly To Google Docs (Google Drive)

May 31, 2012 by Mike Szczys 15 Comments

[Emanuele] is using Google Docs to log his temperature sensor data automatically (translated). We can see a few benefits gained by using this system. One is that you don’t have to visit the site of the logging hardware to harvest the data, another is that Google will automatically graph the data for you. Of course this means you need some way to connect your logger to the Internet, but we’ve seen buckets of different techniques for doing so. In this case, [Emanuele] is using PIC hardware that has a NIC on the board. But the technique could be used from a computer just as easily as from a microcontroller.

The meat and potatoes of the hack is sniffing out the HTTP header and syntax for writing to cells on a Google Docs (soon to be Google Drive) spreadsheet. After making a new spreadsheet and copying the URL and key from the address bar, he loads up the page using a header-viewer web service. With all the pertinent info in hand he crafts about a dozen lines of code to assemble the HTTP packet, and rolls the timestamp and temperature reading into it dynamically. See the system in action after the break.

Continue reading “Data Logging Directly To Google Docs (Google Drive)” →

Using Spy-Bi-Wire With The MSP430 Launchpad

May 29, 2012 by Mike Szczys 10 Comments

[Suraj] has been working with some larger MSP430 chips with won’t fit on the Launchpad board. But that’s okay because he built a shield and wrote a guide about using the Spy-Bi-Wire protocol for programming the chips.

SBW is a four-wire interface. In the past we’ve used all of the board’s programming connections for in circuit programming, but the chips that support SBW only need a connection to the SBW and TEST pins (of course the other two connections are for voltage and ground). This shield brings the four pins together into one male pin header. In the image above [Suraj] is using the technique to program an MSP430F4152. His guide is Windows-based, but looking back, [Sprite_TM] shows how to use SBW when debugging in Eclipse.

Making An Audio Spectrum Analyzer With A Microcontroller

May 29, 2012 by Brian Benchoff 6 Comments

While [Vinod] says he’s not an expert in this sort of thing, we really like his audio spectrum analyzer build from a simple microcontroller and LCD display.

It is a well-studied fact that every audio waveform – a recording of your voice, for instance – is just the sum of many, many sine waves. These sine waves can be plucked out using Fourier analysis, using a Discrete Fourier transform. This is the principle that spectrum analyzers operate under; [Vinod] wrote a bit of code using DFT to take apart audio captured from a microphone and output their frequency on an LCD display.

To output the spectrum on his LCD, [Vinod] stacked horizontal bars up into 8 custom characters in his display. Like [Vinod]’s previous audio on an ATMega32 experiment, an LM324 amplifier is connected to the ATMega through an analog pin. [Vinod] has a very clever build on his hands with his spectrum analyzer, and a great answer to the perennial ‘how do I build a guitar tuner’ questions we’re constantly asked.

After the break, you can see [Vinod]’s spectrum analyzer in action. Be forewarned; you may want to turn down the volume.

Continue reading “Making An Audio Spectrum Analyzer With A Microcontroller” →

Making Capacitive Touch Sensors With Pencil And Paper

May 27, 2012 by Mike Nathan 6 Comments

capacitive-touch-sensor

There are few things more frustrating than being in the middle of working on a project and realizing that you are missing some crucial component that ties the whole thing together. According to Murphy’s Law, this sort of thing will only happen when parts are completely impossible to procure.

If you’re ever hunting for a touch sensor but can’t get your hands on one, [Alan Chatham’s] tutorial on simple DIY capacitive touch sensors might be just what you need to keep things moving along.

[Alan’s] sensors rely on the conductive properties of graphite, which is easily found in just about any pencil on the market. The sensors are created by simply drawing on a piece of paper with a pencil, then wiring the images or text up to your favorite microcontroller via some paperclips and a couple of resistors.

Paper and pencil might not make for the most durable means of input, but we’re pretty sure that [Alan’s] capacitive touch sensors would be very helpful in a pinch. He doesn’t have video of the sensors in action just yet, though he says he’ll put something together here shortly.

Making A Digital Delay From A Simple Microcontroller

May 25, 2012 by Brian Benchoff 12 Comments

If you’d like to start experimenting in DSP, or just want to build a guitar pedal, here’s the project for you. It’s an audio echo using just a microcontroller from the fruitful workshop of [Vinod].

For his circuit, [Vinod] fed the output of a small electret microphone into a small amplifier, and then into the ADC of an ATMega32. Inside the microcontroller, [Vinod] set up a circular array which writes the voltage from the microphone and sends it out to a speaker. Because the array is circular (i.e. it loops around when it gets to the end), [Vinod] has a digital version of a loop of magnetic tape, perfect for recording sounds and playing back echos.

Because [Vinod] is using an ATMega32, he only has a limited amount of RAM to record audio samples. The delay time could be lengthened with a more capable microcontroller, or even the addition of a large RAM chip. With his setup, [Vinod] can do some really interesting experiments with audio and DSP, so we wouldn’t be surprised if an enterprising musician used this project as the basis for a digital delay stomp box.

You can check out [Vinod]’s demo of his echo machine after the break.

Continue reading “Making A Digital Delay From A Simple Microcontroller” →

Salvaged LCD Screen Hacking

May 21, 2012 by Mike Szczys 17 Comments

You can find all kinds of LCD screens in broken electronics. But it’s often a chore to figure out how they are controlled if you don’t have a working device that can be used to sniff the communications protocol. [Justin] grabbed this character LCD screen from an old Brother printer and decided to see if he could reuse it in his own projects. Luckily the driver card still worked so he patched into the LCD’s control lines and sniffed the signals when the printer is powered on.

He used the OpenBench Logic Sniffer for this project. It easily captured the data, and also provided analysis tools. The SPI analyzer managed to decode the command signals and message of “Please wait” that pops up at power up. After a bit of folly with the pin out of the display, he is now able to control it thanks to an Arduino library which he wrote. Check out the demo after the break to seem him scrolling through a bunch of different functions for the device.

Continue reading “Salvaged LCD Screen Hacking” →