BlueMatrix: An Arduino-based LED matrix display

Designed by Dentella Luca, BlueMatrix can be controlled remotely via a PC, smartphone or tablet.

Key project components include:

• An Atmel-based Arduino Uno (ATmega328 MCU)
• 
LED matrix display based on the HC1632C controller
• 
Lipo Rider
• 
Lipo Fuel Gauge
• 
HC-05 Bluetooth module
• 5mm plexiglas enclosure

The modules are connected as follows:

“The Arduino Uno is the heart of the project, [as] it manages the display, checks the battery status and talks (using a simple protocol) with the controlling device (Windows application or Android app),” Luca explained in a recent blog post.

“The BlueMatrix is powered by a Li-po battery (1 cell). The battery’s state of charge is monitored by Lipo Fuel Gauge, which sends the actual SoC (State of Charge) value to Arduino via I2C bus. The Lipo Rider module rises the battery voltage to 5V to power all the other modules and allows it to recharge the battery using a simple, mini-USB power supply.”

Meanwhile, the HC-05 module is tasked with managing Bluetooth connectivity.

“After having established the connection with the remote device, it transparently transport the data received/transmitted by Arduino via serial connection,” said Luca.

On the software side, Luca developed two applications to control BlueMatrix: a .Net application (developed in C#) and an Android app.

“BlueMatrix was designed to be portable, therefore I suppose that it will be mostly controlled using a smartphone; this is the reason why the Android app is better designed than the desktop one and it’s also available on Google’s Play Store,” he added.

Interested in learning more? You can check out the official BlueMatrix project page here and download the Arduino sketch on GitHub here.

Long-range RC controllers for UAVs

Mike and his team recently decided to extend the range of a basic remote control setup for a UAV project.

Ultimately, Mike’s crew decided on a pair of Atmel-powered Arduino Mini boards and Digi Xtend 900Mhz modems to get the job done.

As HackADay’s Will Sweatman notes, the 1 watt transceivers provide a fantastic range of approximately 40 miles.

So, how did Mike do it?

“He set the transmitter up so it can plug directly into any RC controller training port, decoding the incoming signal and converting it into a serial data package for transmitting,” Sweatman explained.

“While they don’t provide the range of other RF transmitters we’ve seen, the 40 mile range of the modem’s are more than enough for most projects, including High Altitude Balloon missions.”

Interested in learning more? The code for the Arduino transmitter system is available on GitHub here, while a Wikipedia page about the project can be accessed here.

Video: AVR raves modded Prophet synth

Atmel microcontrollers (MCUs) have tipped up in a number of synthesizer projects over the past few months including the ATmega328 synth kit and the Atmegatron (8-bit mono).

Today, we’re going to be taking a close look at a recent AVR hack by “Gligli” that skillfully recreates the Prophet 600 – which also just happens to be the world’s very first MIDI synthesizer.

Indeed, at the January, 1983 NAMM convention, the 600 was successfully linked with a Roland Jupiter-6 synthesizer in the first public demonstration of the MIDI protocol. According to Wikipedia, the link was facilitated by a MidiMate hardware interface and MidiTrack program, both developed by Moore and his partner, Paul Rother.

Image Credit: Wikipedia

As the original 600 was powered by a Zilog Z80 microprocessor that controlled modular analog voice chips, Gligli soon discovered that most of the synthesizer’s limitations in the 600 were due to the processor. After creating a PC-based emulator to better acquaint himself with the circuits, Gligli bought a used Prophet and started hacking.

“The [AVR-based] Teensy++ 2.0 (AT90USB1286) required a few hardware mods to fill the Z80’s shoes, including cutting off a pin and adding a few jumper wires. We really like the fact that no changes to the Prophet 600 itself were required,” explained HackADay’s Adam Fabio.

“Pull out the Teensy++, drop in the Z80, and you’re ready to party like it’s 1982 again,. The new processor interfaces directly with the Z80’s 8-bit bus. Since the AVR on the Teensy has built-in RAM and ROM, it simply ignores the ROM and RAM address spaces of the original system.”

Of course, interfacing a fast micro with older parts like an 8253 timer and a 68B50 UART does require some tweaking. More specifically, the system bus has to run slow enough not to violate timing requirements of various peripheral chips. As such, Gligli added wait statements to the upgraded firmware.

“Once the system was working, Gligli was free to start adding new features. He began by smoothing out the stepped envelope and filter generators, as well as adding new exponential modes,” said Fabio.

“From there he added new keyboard polyphony modes as well as pitch and mod wheel changes. Since this is an open source project, adding a feature is as simple as cracking open your favorite editor and writing it up.”

Interested in learning more? You can check out all the relevant project files on GitHub here.

More RAM with the Teensy++ 2.0

So, you’ve decided to use the Atmel-powered Teensy++ 2.0 (AT90USB1286) in your latest Maker project.

Want to know how you can access more memory? 

Well, you’re in luck, because xxxajk recently came up with a library that allows the use of significant RAM expansion with the Teensy++ 2.0.

As HackADay’s Brian Benchoff notes, xxxajk’s latest library is actually a port of XMEM2, an earlier project that added RAM expansion and multitasking to the Arduino Mega (ATmega1280). 

As expected, XMEM2 works with Rugged Circuits QuadRAM and MegaRAM expansions for the Arduino Mega as well as Andy Brown‘s 512 SRAM expansion.

“Up to 255 banks of memory are available and with the supported hardware, the Teensy can address up to 512kB of RAM,” Benchoff explained. 

”XMEM2 also features a preemptive multitasking with up to 16 tasks, the ability to pipe messages between tasks and all the fun of malloc().”

Interested in learning more? You can check out xxxajk/xmem2 on Github here, QuadRAM here, MegaRAM here and the 512 SRAM expansion here.

Driving alphanumeric LCDs with three wires

Writing for HackADay, Brian Benchoff notes that the HD44780 LCD controller is currently the de-facto method of choice for adding a small text display to Maker projects.

“If you need a way to display a few variables, a few lines of text, or adding a small user interface to a project, odds are you’ll be using one of these parallel LCDs,” says Benchoff.

“These displays require at least six control lines, and if you’re using a small microcontroller (MCU) or are down to your last pins, you might want to think about controlling an LCD with a shift register.”

Indeed, a Maker by the name of Matteo recently chose the ubiquitous ’595 shift register configured as a serial to parallel converter to drive his LCD, a method which requires only three pins on an Atmel-based Arduino board. 

On the software side, Matteo modded the stock Arduino LiquidCrystal library and posted it on Gitbub.

“Most of the functions are left untouched, but for this build the LCD can only be used in its four bit mode,” Benchoff adds.

“That’s not a problem for 99% of the time, but if you need custom characters on your LCD you can always connect another shift register.”

Interested in learning more? You can check out Matteo’s official project page here.

SLDongle powered by Atmel’s 88PA

Simon Schoar wanted to offer his colleagues an opportunity to explore the fascinating world of microcontrollers (MCUs). So he came up with the idea to give his co-workers a specially designed Atmel-powered development board nicknamed “SLDongle” for Christmas.

Key components and specs include:

• Atmel ATmega88PA
• 
SCT 2024
• 
LD1117
• 
V-USB
• SPI 
Bootloader

“The technically challenged can plug sld into their USB port and enjoy the beauty of the assembly. The LEDs light up and cycle through different animation sequences,” Schoar explained in a recent blog post. “The more experienced can remote control the LEDs from their USB host by piping data into sldtool (Linux/Mac). The initial delivery contained examples to visualize the CPU utilization (shell for Linux, C for Mac), but the team quickly came up with a nifty ruby solution, counting down the remaining minutes until the next train departs at the station nearby.”

And advanced users? Well, without the need of dedicated ISP hardware they can flash their own C or ASM software directly via USB. More specifically, holding the button while powering up allows sld to enumerate as USBasp, enabling the board to be flashed by avrdude or similar software.

Interested in learning more about the ATmega88PA-powered SLDongle? You can check out Simon Schoar’s blog post here, HackADay’s coverage here and Github here for the corresponding BoM, Eagle/Gerber files and source code.

Das Blinken Bonken! is an Arduino ball game

A Maker by the name of Zippy314 recently designed an Arduino-based game platform as a Christmas present for his son. The project – originally posted to Instructables – was featured earlier this week on HackADay.

“Like all highly addicting games, the Das Blinken Bonken! gameplay is simple; the player throws a ball at the target board while aiming to hit a specific pad,” explained HackADay’s Kevin Darrah.

“There are many game possibilities with this platform, like trying to hit the illuminated target each time, or just trying to hit all of the pads on the board as fast as possible.”

So, how does the game work?

According to Darrah, the pads register a hit with the help of home-made pressure sensors – each constructed in a ‘sandwich’ of pressure-sensitive conductive sheets. 

Since the resistance through the sheet lowers as pressure is applied, a simple voltage divider circuit is used to feed the analog inputs on the Arduino Uno (Atmel ATmega328), thus making it easy to detect an impact.

Meanwhile, an I2C 4-Digit 7 Segment display keeps score and displays the game title, with a strip of addressable RGB LEDs providing player feedback and other gameplay data.

Interested in building your own Das Blinken Bonken? You can check out the project’s official Instructables page here and the relevant Arduino files on Github here. Once the software is installed via GitGub and everything hooked up correctly, Makers should see the word “AIM” spelled out on the display.

“Navigate the menu by pressing on the top two target segments until you see the display read ‘CAL’ Now press the target center to activate calibration,” Zippy314 explained in his Instructables post.

“This mode simply reads the amount of pressure being detected on the pressure pad you press on. You can use this mode to adjust the tightness of the screws so all the pads are roughly equal. To get back to the menu press the top two target segments simultaneously.”

There are currently four Das Blinken Bonken games available: Aim, Speed, Fill, & Red vs. Blue. However,  Zippy314 is encouraging Makers to submit additional ones.

A flickering LED candle in a jar with Adafruit’s Trinket

Tim Bartlett says he’s always wanted to create a small light with realistic fire (flickering) animation. Enter Bartlett’s LED candle in a jar – just in time for the winter holiday season.

“Its brain is a programmable microcontroller, running a smart RGB LED via a single data pin, housed in the lid of a jar,” Bartlett explains. “I used Adafruit’s [Atmel-powered] Trinket — a tiny, inexpensive board available in 3.3V or 5V flavors.

”

Thus far, Bartlett has created three prototypes:

• A self-contained 3.3V candle with a single Atmel-based Flora NeoPixel, powered by a tiny rechargeable 150mAh lipo battery inside the lid, with a pushbutton toggle power switch hot glued to the outside of the lid.
• A 5V single-pixel candle, with Trinket on the outside for powering via USB, plus an extra 2.1mm socket for external wall or battery power.
• A 5V 8-pixel candle using Adafruit’s 8 NeoPixel Stick, with all electronics inside the lid and a 2.1mm power socket on top.

“The jars have a white paper disc at the bottom and a tracing paper tube running the jar’s height. I plan on replacing them with some theatrical lighting diffusion so nothing bursts into flame — probably not a risk, but you never know,” says Bartlett.

“The Arduino code runs a basic fade on the green pixel, causing it to dip down and back every 120 milliseconds, roughly 8 times per second. When the green dips, the light gets dimmer and redder, as if it’s losing oxygen. An RGB mix of 255, 100, 10 (on a scale of 0 – 255) looks like a pretty good candle flame yellow to me.”

Interested in learning more? You can check out the project’s official page here and the full code on Github here.

Open Informant takes on surveillance in a networked age

Open Informant – powered by an Arduino Pro Mini (Atmel ATmega168) – is a wearable badge with an e-ink display that “attempts to confront the unsettling realities of surveillance in a networked age.”

Designed by the Superflux crew, the device was recently exhibited at the Wearable Futures 2013 Conference.

“Open Informant is [both] a phone app and e-ink badge. The app searches your communications for NSA trigger words and then sends text fragments containing these words to the badge for public display,” a Superflux rep explained in a recent blog post.

“Using the body as an instrument for protest, the badge becomes a means of rendering our own voice visible in an otherwise faceless technological panopticon. By openly displaying what is currently taken by forceful stealth, we question the intrusive forms of mass surveillance adopted by democratic nations on its own citizenry, and in the process, shift the conversation around wearables from being about you and your body as machine, to the culture of machine intelligence and algorithmic monitoring.”

According to the Superflux rep, the aesthetics of the wearable device are purposefully embedded in popular DIY Maker culture to encourage greater adoption and use. As such, all aspects of the badge’s design and construction are available on Github for DIY Makers to use and mod.

It should be noted that the Open Informant was recently featured on the official Arduino blog.

ATmega328 powers this wireless motion sensor

A talented Maker by the name of Felix Rusu has designed a wireless PIR sensor node built around the ATmega328-based Moteino, an uber-mini board with solder pads for RFM12B and RFM69 radio transceivers.

As HackADay’s Brian Benchoff notes, the inexpensive radios – priced at approximately $4 each – are capable of transmitting about half a kilometer at 38.4 kbps, a rather impressive amount of bandwidth, especially for a very inexpensive system.

“The important bit on this wireless sensor, the PIR sensor, connects with three pins – power, ground, and out,” Benchoff explained. “When the PIR sensor sees something it transmits a code the base station where the ‘motion’ alert message is displayed.

Rusu, who is also a systems engineer, described the schematic/wiring as “trivial.”

“The PIR sensor can take anywhere from 5V to 9V or even more, [although] I used a 9V battery since it’s pretty compact. Later I want to try using lipos with a Moteino shield I am working on. The OUT pin goes high for a specific length of time when motion is detected (adjustable by side pot, I turned mine to minimum to limit LED power consumption). The sensitivity is also adjustable by another small side pot,” Rusu wrote in a recent blog post.

“The wonderful thing is that this PIR sensor is very cheap and uses about 60uA when idle and about 200uA when active! Coupled with a low power LED for visual indication the overall power consumption is very low. Of course the Moteino and everything on it has to be put to sleep. The OUT pin is connected to a low power 2mA red LED and to the hardware interrupt INT1 (digital pin D3 of Moteino). This way the sketch sleeps indefinitely, and when motion is detected the LED lights up and Moteino wakes up and quickly sends an ACK-ed ‘MOTION’ alert message.”

Interested in learning more? The low power Moteino sketch along with case plans are available here on Github.