Arduino Mega drives this Roboartist

A trio of Makers – Niazangels, Maxarjun and Ashwin – have designed a particularly impressive Arduino-based vector drawing robot.

According to HackADay’s Mike Szcys, the most notable feature of the build is the robot’s ability to process what it “sees” via a standard webcam and subsequently sketch an accurate image with a pen and paper.

“The arm itself has four stages and remarkably little slop. The remaining slight wiggle is just enough to make the images seem as if they were not printed to perfection and we like that effect,” he explained.

“The hardware uses an [Atmel-based] Arduino Mega (ATmega2560) to take input via USB or Bluetooth and drives the quartet of servo motors accordingly.”

The Roboartist runs a modded version of the Canny Edge Detector to precisely determine where to place the pen strokes. Currently, MATLAB is included in the software, although Szcys confirms the trio of Makers plan to move towards alternative open source tools in the future.

“In addition to the LEDs you can see around the perimeter of the acrylic drawing surface, there are also rows of RGB strips below,” he said.

“The software runs a filter for the under lighting in order to compliment the lines on the paper. This is why there is a violet hue that fades out toward one side of the drawing.”

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

The Stargate-Arduino (Chappa’ai) connection

A Stargate is a portal device within the fictional SG universe that facilitates practical, rapid travel between two distant locations.

According to Wikipedia, the devices first appear in the 1994 Roland Emmerich film Stargate – and subsequently in the television series Stargate SG-1 Stargate Atlantis and Stargate Universe. 

The stargates – created millions of years ago by an alien civilization known as the Ancients – typically measures 4.6 m (15 ft) in diameter and weighs in at 29 metric tons (64,000 pounds).

Since a “proper” sized stargate may be a little too big for the average living room, den or basement, a Maker by the name of Shlonkin is working to create a smaller replica, (19cm in diameter), complete with a dialing computer.

“It will move and light up just like the version in SG-1. When a proper address is dialed, a connection will be opened up via the Internet to a corresponding device or computer,” Shlonkin explained in a recent HackADay blog post.

“Exactly what will be transmitted has not yet been decided. The hardware/Internet interface will be via [an Atmel-based] Arduino Uno (ATmega328 MCU). One team member, myself, will design and build the physical device. Another member, Dkopta, will create the software.”

Aside from the Atmel-based Uno, key project components include:

• Two 1.2mm polypropylene sheet
• Two 3mm polypropylene cutting board
• One wireless 10-key (IR)
• One stepper motor
• One SN754410 H-Bridge for the motor
• 7 red SMD LEDs and 1k resistors
• One plastic food container
• Assorted paints

“I will definitely post all the build details, but not until I make a little more progress. The parts are made with hand tools. I’ll probably use some thin(5mm) HDPE boards that are really easy to carve. I’ve never done anything this detailed with HDPE, so it will be a learning experience,” he added.

“We will go as far as we can get before the end of the contest. I would love it if the top chevron moved like in SG-1, but since it is so small(about 2cm) I don’t know if I will be able to pull it off, [but] I’ll think [about] it.”

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

Self-learning ‘copter navigates with an ATmega644 MCU

Akshay Dhawan and Sergio Biagioni of Cornell University have designed a self-learning (RC) helicopter powered by an advanced machine learning algorithm paired with Atmel’s ATmega644 microcontroller (MCU).

Aside from Atmel’s ATmega644 MCU, key project components include:

• Syma S107 Micro Helicopter
• Custom PC Board (for MCU)
• RS232 UART connector
• Max233CP
• Power Supply
• Infrared Emitter 365-1056-ND
• Infrared Receiver 160-1030-ND
• Wooden platform
• Balsa wood 24 inch dowel
• White board (holds phototransistor circuit)

As HackADay’s Will Sweatman reports, the ‘copter is attached to a boom which restricts its movement down to one degree of motion. Meaning, the helicopter can only move up from the ground, rather than side to side or front to back.

“The goal is for the helicopter to teach itself how to get to a specific height in the quickest amount of time. A handful of IR sensors are used to tell the ATmega644 how high the helicopter is,” writes Sweatman.

“The genius of this though, is in the firmware. Akshay and [Sergio] are using an evolutionary algorithm adopted from Floreano et al, a noted author on biological inspired artificial intelligences.”

Essentially, the ‘copter creates random “runs” and then check the data. The runs that are closer to the goal are refined, while the others are eliminated in a process that emulates evolution via natural selection. In short, the project’s goal is for the ‘copter to start at Point A, go to Point C and hover. The allotted time is 10 seconds per run, with the helicopter expected to teach itself the routine as quickly as possible.

“A neural network is used to determine at what level the throttle should be at to achieve the highest Fitness Value. This network is a part of the Evolutionary Algorithm that runs in the firmware. Basically, it starts off with random values that generate random levels of throttle,” Sweatman explains.

“The values that achieve the highest Fitness Value get ‘mutated’, while the others are discarded. The mutations in the values are done at random and the process repeats. In the end, the firmware learns the best throttle levels to achieve the goal of being at Point C for the longest time in the allotted 10 seconds.”

Interested in learning more about the self-learning ‘copter? You can check out the project’s official Cornell page here.

How to build an Uno-based 3D scanner

Till Handel (aka alicedownthecoffeepot) has published a detailed paper describing how to build a relatively inexpensive 3D scanner using an Atmel-based (ATmega328 MCU) Arduino Uno board and assorted spare parts, such as those scavenged from old printers and laptops.

As HackADay’s James Hobson reports, the Uno-equipped platform is capable of scanning 360° around itself at distances from 0.3 – 5m, making it a perfect fit for scanning rooms.

“It uses a line laser and a webcam mounted on an arm driven by a stepper motor, which looks like it’s out of an old optical drive,” Hobson explains.

“[Meanwhile], an Arduino Uno and an A4988POW stepper driver control the system.”

According to Hosbon, Handel’s 3D scanner is similar to others on the market, with a line laser providing a 2D profile/outline of the object being scanned that the camera picks up.

“As the system (or object) rotates, new profiles are recorded and sewn together to form a complete 3D image,” says Hobson.

“To increase the resolution and accuracy of the scanner, you can always [use] a better camera.”

Interested in learning more? You can check out Till Handel’s blog post here and detailed paper (published under GPLv3) here.

Video: Designing a mesh networked conference badge

Andrew Nohawk recently attended ZaCon V, a free South African security conference. In honor of the event, Nohawk decided to design an interactive mesh networked conference badge.

As HackADay’s Mathieu Stephan reports, the slick platform is powered by Atmel’s stalwart ATmega328 microcontroller (MCU). Additional features include a Nokia 5110 LCD, a 433MHz AM/OOK TX/RX module, a few LEDs and an assortment of buttons.

“The badges form a mesh network to send messages. This allows conversations between different attendees to be tracked,” Stephan explained.

“Final cost was the main constraint during this adventure, which is why these particular components were chosen and bought from eBay & Alibaba.”

According to Stephan, the first PCP prototypes were CNC milled and required quite a bit of soldering to finish off the 77 final boards. Meanwhile, the protocol itself was verified using Maltego.

“Of the 77 badges soldered together (at various stages of ‘full working order’ – especially the BYOB people) the front computer captured 9810 transmissions, 49 badges and 201 different relationships,” Nohwak confirmed in a blog post detailing the project.

Interested in learning more? You can access the relevant code, raw sqlite database and Maltego graphs from GitHub here or visit the project’s official blog post here.

ATmega644 MCU powers phased array speaker system

Edward Szoka (ecs227) and Tom Jackson (tcj26) of Cornell University have designed a phased array speaker system capable of “steering” sound around a room.

As HackADay’s Will Sweatman reports, the ATmega644-powered platform samples a standard audio input signal at approximately 44.1 kHz via 12 independently controllable speakers – each with a variable delay.

 Simply put, the angle of maximum intensity of the output wave can be shifted by adjusting the delay at precise intervals.

“Phased arrays are usually associated with EM applications, such as radar. But the same principles can be applied to sound waveforms,” Sweatman explained.

The basic idea behind a phased-array? By changing how the speakers are driven, the angle of the maximum intensity of the output wave can be shifted.

“This type of array was built to be able to support various other more advanced design challenges, including longer-range acoustic modem transmission and sonar imaging,” they added.

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

Video: This giant LED Tamagotchi hearts Atmel

The Tamagotchi (たまごっち?) is a handheld digital pet, originally designed in Japan by Akihiro Yokoi of WiZ and Aki Maita of Bandai way back in 1996. According to Wikipedia, well over 76 million Tamagotchis have been sold world-wide.

Image Credit: Wikipedia

The majority of Tamagotchis are housed in a small egg-shaped computer with an interface (typically) consisting of three buttons, although the number of buttons may vary.

However, a Maker by the name of Vadim recently decided to create a unique, desktop-sized Tamagotchi using a spare LED matrix and an Atmel ATmega328P microcontroller (MCU) with an Arduino bootloader.

As HackADay’s James Hobson reports, the LED matrix comprises four 8×8 LED modules with four shift registers (74HC595) and two Darlington transistor arrays to take the current.

“This is because the 256 LEDs need to be multiplexed down to 32 IO’s (16 rows + 16 columns),” he explained.

After the hardware was deemed operational, Vadim started work on the coding side of things, writing the entire game from scratch.

“While it’s not that complex it’s still an impressive amount of effort that went into this desktop- sized Tamagotchi!” Hobson added.

Interested in learning more? You can check out the project’s official Instructables page 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.

Atmel-based BASIC computer makes us nostalgic

BASIC, or Beginner’s All-purpose Symbolic Instruction Code, is a series of general-purpose, high-level programming languages that emphasizes ease of use. According to Wikipedia, John G. Kemeny and Thomas E. Kurtz designed the original BASIC language at Dartmouth College in New Hampshire way back in 1964.

Multiple dialects of BASIC were written over the years, with the TinyBASIC variant capable of fitting into as little as 2 or 3 KB of memory. This small size made it quite useful in the early days of microcomputers (the mid-1970s), when typical memory size weighed in at 4–8 KB.

Recently, a Maker named Dan decided to design a simple, tiny 8-bit computer to run the succinct TinyBASIC.

As HackADay’s Brian Benchoff reports, the computer is built around the Arduino Uno (ATmega328) and a custom-made AVR-based shield, using TinyBASIC, the TVout library and the PS/2 keyboard library.

“After piecing together a little bit of code, the Arduino IDE alerted Dan to the fact the TVout and PS/2 libraries were incompatible with each other,” Benchoff explained. 

”This inspired Dan to use the ATmega328 as a coprocessor running the TVout library, and using the capacious ATmega1284P as the home of TinyBASIC and the PS/2 library.”

Subsequently, Dan used Fritzing to design a circuit using minimal components, with a custom PCB milled out of copper board.

“After the board was tinned, [Dan] had a beautiful minimalist retro computer with nearly 14kB of RAM free and an RCA display,” added Benchoff. 

The final setup comprises the shield, an Arduino UNO, PS/2 keyboard, RCA capable display (such as an LCD TV), RCA cable and a power source (such as a wall mounted PSU).

Future iterations of the Atmel-powered TinyBASIC computer will likely be based around the stalwart Arduino Mega (ATmega1280), facilitating a TV resolution of 720×480. Additional features could include an SD card slot, LEDs, pots and perhaps even headers for I2C and SPI.

Interested in learning more?

You can check out the project’s official Instructables page here.

ATmega328 external serial monitoring – sans PC

Serial monitors are typically used to help Makers and engineers more easily debug their projects.

However, as HackADay’s Will Sweatman notes, traditional serial monitors require a PC or laptop loaded with a terminal program.

“Most of the time this is not an issue, because the PC is used to compile the code and program the project at hand,” Sweatman explained.

“But what if you’re in the field, with a mission of fixing a headless system and in need a serial monitor? Why lug around your PC when you can make your own external serial monitor?”

And that is precisely why ARPix designed a barebones, albeit fully functional serial monitor around Atmel’s versatile ATmega328 microcontroller (MCU) and a 102 x 64 LCD display.

Although the minimalistic platform lacks a keyboard port like some other external monitors, tact switches facilitate access to the user interface (UI) for start and stop commands. As expected, the tact switches can also be used to set the baud rate.

Interested in learning more? You can check out the project’s official Instructables page here, which offers the relevant sketches and parts list.