This MP3 player is powered by an Arduino Uno (ATmega328)

A Maker by the name of Arons recently decided to create a barebones MP3 player for his daughter based on the Hörbert.

Dubbed MBox, the device is capable of playing a wide range of audio formats, including MP3, MIDI, WAV and Ogg Vorbis.

 The platform is powered by an Arduino Uno (Atmel ATmega328) paired with a Freaduino MP3 music shield.

The MBox is capable of playing a wide range of audio formats, including MP3, MIDI, WAV and Ogg Vorbis. 

Additional components include a mono audio amp breakout, 2-10KΩ resistors, loudspeaker, keypad, 2KΩ potentiometer, on/off switch, USB power bank, wood and yes, even a piece of an old climbing rope.

Arons neatly placed all the components into a wood box, utilizing the old climbing rope as grab, with the USB port fitted in the back to easily charge the power bank.

“The MBox [supports] SD cards (FAT 16 or 32) and contains 12 directories starting from 0 to 12,” he explained in a project blog post. “Every button of the keypad is associated [with] a directory.” Meaning, each number plays from a different directory on the SD card.

Arons says his daughter is happy with the MBox and uses it quite frequently.

“I was really impressed to see how quickly she learned to select the track she wants to play,” he added.

Interested in learning more about the Arduino-powered MBox? You can check out the project’s official page here and HackADay’s write up here.

Hacking and tracking an RC car

A Maker by the name of Shazin recently posted an RC car hack that tracks (and follows) the face of a user. The first step of the project? Assuming direct control of the RC vehicle.

“The uniqueness in this approach is that many people have [executed] RC car hacks using Arduino to control the RC, [rather than] the car itself,” Shazin explained in a recent blog post. “[This] hack directly controls the car instead of sending commands using the RC.”

As HackADay’s Kevin Darrah points out, the car used in the project isn’t exactly high-end, so Shazin had to forego about PWM control.

“Instead, a single IC (RX-2) was found to handle both the RF Receiver and H-Bridges,” writes Darrah.

“After a bit of probing, the four control lines (forward/back and left/right) were identified and connected to an [Atmel-based] Arduino.”

Shazin then paired the Arduino with a USB host shield, linking it with his Android phone via ADB (Android Debug Bridge), while also tweaking the OpenCV Android Face Detection app for the project.

“If the first detected face (target) is in the right half of the image, then turn right or else turn left and go forward,” notes Shazin.

Interested in learning more about the user tracking car? You can check out Shazin’s project page here and HackADay’s coverage here.

Arduino Uno powers this Game of Life clock

The Game of Life (aka Life) can best be described as a cellular automaton created by the British mathematician John Horton Conway in 1970. Essentially, it is a zero-player game, meaning that its very evolution is determined by an initial state, requiring no further input. Simply put, an individual interacts with the Game of Life by creating an initial configuration and observing how it evolves.

The game made its first public appearance in the October 1970 issue of Scientific American, having been featured in Martin Gardner’s “Mathematical Games” column. As Wikipedia notes, the game is rather interesting from a theoretical point of view, as it has the power of a universal Turing machine, namely anything that can be computed algorithmically can be computed within Conway’s Game of Life.

Recently, a Maker by the name of Matthews created a Game of Life style clock. According to HackADay’s James Hobson, Matthews was originally inspired by another Game of Life Clock featured on HackADay a few months ago, although he did implement a number of critical changes.



”First, Matthews wanted a much bigger playing field, so he found a 16×32 RGB LED matrix. Second, he wanted the time to always be visible so it actually works as a functional clock,” Hobson explained.

“At the beginning of every minute starts a new Game of Life which plays over top of the time displayed. Three buttons on the top allow for many adjustments including brightness, timezone, speed, colors and even edge behavior.

”

The Game of Life clock is powered by an Atmel-based Arduino Uno (ATmega328) paired with a Chronodot RTC module to assist with accurate time keeping.

Interested in learning more about the Game of Life clock? You can check out the project’s official page here.

Video: Arduino Uno powers revamped CNC machine

A Maker by the name of Shane has up-cycled an old HP printer, transforming the device into a fully-functioning CNC machine.

According to the HackADay crew, Shane made use of the entire 2500C A3 printer to build the new platform.

“While he was taking it apart [for parts], he realized the chassis would make a great frame for his actual CNC machine. With that in mind Shane quickly changed his game plan to making each axis inside of the printer,” explained HackADay’s James Hobson.

“He’s using regular ball bearing drawer runners for both the X and Z axes, covered with a clever design of aluminum angle to keep any possible chips from jamming them. The Y axis on the other hand makes use of the original shaft runners from the print head carriage. Each axis is driven by threaded rod using recycled stepper motors from the printer.”

The CNC machine is powered by an Atmel-based Arduino Uno (ATmega328), along with a Protoneer CNC shield to control the stepper drivers. Additional features include an emergency stop, hold, resume and cancel buttons for manual control.

Interested in learning more about the Arduino-powered CNC machine? You can check out the project’s official page here.

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.

Designing an Arduino-controlled autopiloted sailboat

Jack Edwards, a mechanical engineer and loom builder, recently built a functioning Arduino-based autopilot system for the Wile E. Coyote, his 1983 Robert Perry Nordic 40 sailboat.

According to The Marine Installer Rant, the system successfully piloted Jack’s boat over 400 miles this past summer using both heading and GPS track mode with cross track error correction.

As the HackADay crew notes, the system is built around two Arduino Mega boards (Atmel ATmega1280).

“One is solely for the GPS, and the other controls everything else. Jack’s autopilot has three modes. In the one he calls knob steering, a potentiometer drives the existing hydraulic pump, which he controls with a Polulu Qik serial DC motor controller,” explains HackADay’s Kristina Panos.

“In compass steering mode, a Pololu IMU locks in the heading to steer (HTS). [Meanwhile], GPS mode uses a predetermined waypoint and sets the course to steer (CTS) to the same bearing as the waypoint.”

Jack’s autopilot system also employs cross track error (XTE) correction to calculate a new HTS when necessary.

Interested in learning more? You can check out extensive coverage of the project by The Marine Installer Rant here, HackADay’s write up here, as well as the relevant Fritzing and Arduino files here. Previous stories about marine-based autopilots featured on Atmel’s Bits & Pieces include “This Sailboat Autopilot has Arduino Under the Hood” and “Building a Compass Guided Kayak.”

Video: ATmega16 powers this floppy disk jukebox

The earliest floppy disks – developed in the late 1960s – measured 8 inches (200 mm) in diameter and first became commercially available in 1971.

Image Credit: Wikipedia

However, it wasn’t long before the 5¼ inch format displaced its 8-inch one predecessor for most applications, before itself being supplanted by 31⁄2-inch disks. 


According to Wikipedia, the advantages of the ubiquitous 3 1⁄2-inch disk were its smaller size and plastic case which provided improved protection from dust and other environmental risks.

Granted, it’s been quite a while since most of us have seen a floppy disc, especially in an age when DVDs and CDs are already perceived as quite dated. Yet, one can’t help being overcome by a wave of nostalgia when coming across a project utilizing the retired medium. 

Kiu’s (Simon Schoar) RumbleRail is one such example. As HackADay’s Brian Benchoff notes, the engineering and design quality that went into the build puts the device in a class by itself.

“Instead of the usual assemblage of wires, power cords and circuits that accompany most musical floppy drive builds, Kiu‘s is an exercise in precision and modularity,” he explained. “Each of the eight floppy drives are connected to its own driver with Atmel’s ATmega16 microcontroller (MCU) on board.”

More specifically, each floppy is driven by an ATmega16A-AU, while the “heavy lifting” of decoding MIDI files and driving the display is executed by an ATmega1284P-AU.

“The microcontrollers in these driver boards receive orders from the command board over an I2C bus,” Benchoff continued. “Since everything on the RumbleRail is modular, and the fact Kiu is using DIP switches to set the I2C address of each board, this build could theoretically be expanded to 127 voices, or 127 individual floppy drives each playing their part of a MIDI file.”

The RumbleRail is more than capable of operating in standalone mode without a PC. Indeed, MIDI files are loaded from an SD card and decoded by the main controller board.

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

ATmega1284P powers this gesture-based security lock

A team of Cornell University students has designed a security lock that 
opens after verifying a stored gesture pattern.

“The idea is to create a box like assembly, in which the user places his hand, makes a defined gesture and unlocks the system. Basically, there is a mechanism that allows the user to save a gesture pattern,” a team rep wrote on the project’s official page.

“Once that is done, the system goes in lock state. When the user enters his hand in the box, he tries to recreate the same pattern. If he is able to do so, the system unlocks. If unable to, the system remains locked.”

According to the rep, the project was inspired by a popular mobile phone unlock feature where a user draws a pattern on the screen to activate the device.

“We wanted to create a similar system which could be used in any security application, as simple as opening the door of the house based on the gesture,” the rep explained.

 “The attractive feature of the project is that the user makes the pattern in the air and not on any surface. Also, we have given the user the flexibility of changing the pattern whenever he wishes to do so.”

The gesture-based security lock is powered by Atmel’s versatile ATmega1284P microcontroller (MCU), a custom PCB and an IR proximity sensor. Additional key components include a three-pin jumper cable, breadboard, power supply, toggle switch, push button, LEDs, 330ohm resistors, assorted wires and a cardboard frame. 

On the software side, the project employs a series of algorithms for switches/inputs, store mode, pattern matching and four channel ADC multiplexing.

“Overall, our system performs satisfactorily and can be effectively used to create a gesture-based secure unlock,” the team rep concluded. “Given more time and budget, we could have made the system 3D. Changes in the third dimension could be used to model the system, [thereby] increasing system accuracy and giving the user another dimension for creating the patterns.”

Interested in learning more about the Atmel-powered gesture-based security system? You can check out the project’s official page here and HackADay’s write-up here.

Storing passwords with the ATmega32U2

Earlier this month, the HackADay crew confirmed that it had chosen Atmel’s ATmega 32U4 microcontroller (MCU) to power an offline password keeper known as “Mooltipass.”

As it turns out, a Maker by the name of Josh is working on a similar offline password keeper, albeit with an ATmega32U2 instead of the 32U4.

Like the Mooltipass, the USBPass is connected to a computer via USB and read as an HID keyboard. Aside from the ATmega32U2, the platform is equipped with a minimal amount of components, including a USB connector, three buttons and a few passives chips.

“A total of 20 passwords can be stored in the microcontroller’s memory, which can be ‘typed’ by the platform using the push buttons,” explained HackADay’s Mathieu Stephan.

On the software side, the USBPass firmware is based around the LUFA USB stack, to which Josh added HID report functionality to facilitate data transfer from his desktop application.

“The latter uses the Linux/Windows/OS X HID API library so bringing his software to other operating systems can be done in no time,” Stephan added.

Although the current version of the USBPass is pretty sweet indeed, Josh says he is working on a second iteration of the platform which will likely boast an OLED screen.

Interested in learning more about the Atmel-powered USBPass? You can check out the project’s official page here and the relevant GitHub files here.

Emulating contactless smart cards with the ATxmega192A3

Researchers at Ruhr University of Bochum in Germany recently debuted the Chameleon Mini, a versatile contactless smart card emulator. 

As HackADay’s Adam Fabio notes, contactless smart cards are RFID style devices that also contain a smart card style memory. These cards are often used for payment, replacing mag strip style credit cards.

According to the researchers, Chameleon was designed as a programmable platform to assess security risks in RFID environments, as the device can be used in various attack scenarios.

“The Chameleon is set up to emulate any number of cards using the common 13.56MHz frequency band,” HackADay’s Fabio explained. “Adding a new card is as simple as loading up a new CODEC  and application to the firmware. Currently Chameleon can emulate MIFARE cards using the ISO14443A.”

The open source Chameleon – powered by Atmel’s versatile ATxmega192A3 mcirocontroller (MCU) – was built for around $25. As Fabio points out, the 192 is a perfect fit for the Chameleon, because it is equipped with hardware accelerators for both DES and AES-128.

Additional key project specs include:

• Hardware support for ASK modulation (both 10% and 100%) to cover almost any card standard available.
• Hardware support for ASK and BPSK load modulation using a subcarrier.
• Modular firmware structure faclitates easy expandability of other cards and standards.
• Support for quick and reliable firmware update via Atmel DFU boot loader (programming hardware is required only once).
• Can be controlled using a fully documented AT-like command set via CDC using theLUFA USB stack.
• 1MByte of card memory allows for multiple card emulations to reside on the device simultaneously.
• Settings can be switched even without a USB connection, simply by pressing a button.
• Card contents can be easily uploaded and downloaded by means of the command line and X-MODEM. This allows the Chameleon to be interfaced with standard terminal software as well as user written scripts and applications.

Interested in learning more about the Atmel-powered Chameleon? You can check out the project’s official page here.