Breadboarding with a ARM microcontroller

ARM

NXP’s LPC1114 ARM microcontroller is in a class all of it’s own. ARM microcontrollers are a dime a dozen, but this fabulous chip is the only one that’s housed in a hacker and breadboard friendly PDIP package. However, breadboard setups usually won’t have the luxuries of a true development platform such as flashing the part, single stepping through the code, and examining memory. [Steve] found an interesting solution to this problem that involves a Dremel and hacking up even more hardware.

[Steve] found a few LPC1769 dev boards that include a debugger and a way to program these chips. Simply by hacking off the programmer and debugger portion of this dev board with a Dremel tool, [Steve] had an easy to use interface for his breadboardable ARM.

After connecting the power rails to his breadboarded chip, [Steve] connected his programmer up and set up a gcc toolchain. For about $25, he has a breadboard friendly ARM microcontroller with full debugging capabilities.

This isn’t the first time we’ve seen a few people play with this DIP28 ARM chip; someone even milled this 600 mil chip down to 300 mils for even easier prototyping. Still, this is the best and cheapest way we’ve seen yet to turn this ARM into a proper prototyping platform.

Advanced Transcend WiFi SD Hacking: Custom Kernels, X, and Firefox

ts-wifi-advanced

[Dmitry] read about hacking the Transcend WiFi cards, and decided to give it a try himself.   We already covered [Pablo's] work with the Transcend card. [Dmitry] took a different enough approach to warrant a second look.

Rather than work from the web interface and user scripts down, [Dmitry] decided to start from Transcend’s GPL package and work his way up. Unfortunately, he found that the package was woefully incomplete – putting the card firmly into the “violates GPL” category. Undaunted, [Dmitry] fired off some emails to the support staff and soldiered on.

It turns out the card uses u-boot to expand the kernel and basic file system into a ramdisk. Unfortunately the size is limited to 3MB. The limit is hard-coded into u-boot, the sources of which transcend didn’t include in the GPL package.

[Dmitry] was able to create his own binary image within the 3MB limit and load it on the card. He discovered a few very interesting (and scary) things. The flash file system must be formatted FAT32, or the controller will become very upset. The 16 (or 32)GB of flash is also mounted read/write to TWO operating systems. Linux on the SD card, and whatever host system the card happens to be plugged in to. This is dangerous to say the least. Any write to the flash could cause a collision leading to lost data – or even a completely corrupt file system. [Read more...]

The Bitbox Console: an Open Source Gaming Rig

Bitbox Console

A simple resistive DAC is all you need to drive a VGA display. Combining that with an on-chip DAC for audio, the STM32F405RGT6 looks like a good choice for a DIY game console. [Makapuf's] Bitbox console is a single chip gaming machine based on the STM32 ARM processor.

We’ve seen some DIY consoles in the past. The Uzebox is a popular 8 bit open source game system, and [makapuf] was inspired by its design. His console’s use of a more powerful 32 bit processor will allow for more complex games. It will also provide more colors and higher quality audio.

One of the keys of the Uzebox’s success is the development tools around it. There’s a full emulator which allows for debugging with GDB. [Makapuf] has already built an SDL based emulator, and can debug the target remotely using GDB. This will certainly speed up game development.

After the break, check out a demo of the first game for the Bitbox: JUMP. Also be sure to read through [makapuf]‘s blog for detailed information on the build.

[Read more...]

Octoscroller takes the Hexascroller to the next level

octosc2

The folks at NYCResistor have a new toy in the Octoscroller. For a couple of years now the NYCResistor crew has used the HexaScroller as a clock and general alert system. Now that RGB LED panels are cheaply available, the group decided to upgrade both the number of sides and the number of colors.

Octoscroller uses eight 16×32 RGB LED panels. These panels are relatively easy to interface to, but require constant refresh even to display a static image. This makes them both memory and CPU intensive for smaller microcontrollers. Brightness control via PWM only increases the difficulty.

On the plus side, the panels are structurally strong. This allows the Octoscroller to avoid the plywood ring which made up the frame of the Hexascroller. 3D printed brackets and hardware were all that was needed to complete the Octoscroller frame.

The brain of the this beast is a BeagleBone Black running LEDscape along with some custom software. Imagery comes from the Disorient Pyramid.

If you’re in the New York area, NYCResistor plans to offer classes on building your own Octoscroller.  You can also see the Octoscroller in person at MakerFaire NYC this weekend.

An RTL-SDR Spectrum Analyzer

RTL

With the combination of small, powerful, and pocketable computers and cheap, off-the-shelf software defined radio receivers, it was only a matter of time before someone built a homebrew spectrum analyzer with these ingredients. This great build is the project of [Stephen Ong] and he’s even released all the softwares for you to build this on your own.

The two main components of this build are a BeagleBone Black and its 7″ Touchscreen cape. The BeagleBone is running Angstrom Linux, a blazingly fast Linux distro for small embedded devices. The radio hardware consists of only a USB TV tuner supported by RTL-SDR. In his demo video, [Stephen] shows off his project and by all accounts it is remarkable, with a UI better than most desktop-oriented SDR software suites.

You can grab the BeagleBone image [Stephen] is using over on his blog, but for more enterprising reader, he’s also put up the source of his ViewRF software up on GitHub.

The JavaScript of Things

Espruino

There are a ton of people out there that can program in JavaScript, but give them an embedded device, and they’re up the creek without a paddle. Not anymore, that is, thanks to [Gordon]‘s wonderful Espruino, a JavaScript interpreter for ARM microcontrollers. Oh, it’s also a very capable dev board that has more than enough power to turn just about any project you can imagine into reality.

On board the Espruino is an ARM Cortex M3 in the form of an STM32 chip, 256kB Flash, 48kB of RAM, and a ton of PWM and ADC pins to go along with 2 SPI ports, 2 I2C ports, and 2 DACs. It’s a very capable piece of hardware, and if you’re looking to build anything, it would be hard to pick a better general purpose dev board.

[Gordon] has put his board up on Kickstarter, and since it’s already been successfully funded, he’ll be releasing the hardware and software sources under an Open Source license. If you’ve ever wanted to run JavaScript on an ARM board, it looks like Espruino is just the ticket.

Evalbot as a JTAG programmer

evalbot-as-jtag-programmer

[Adarsh] needed a JTAG programmer to push code to a CPLD dev board he was working with. He knew he didn’t have a dedicated programmer but figured he could come up with something. Pictured above is his hack to use a Stellaris Evalbot as a programmer.

Long time readers will remember the Evalbot coupon code debacle of 2010. The kits were being offered with a $125 discount as part of a conference. We were tipped off about the code not know its restrictions, and the rest is history. We figure there’s a number of readers who have one collecting dust (except for people like [Adam] that used it as a webserver). Here’s your chance to pull it out again and have some fun.

A bit of soldering to test points on the board is all it takes. The connections are made on the J4 footprint which is an unpopulated ICDI header. On the software side [Adarsh] used OpenOCD with stock configuration and board files (specifics in his writeup) to connect to the white CPLD board using JTAG.