Introducing the BeagleTouch

Antipasto Hardware Blog

Wednesday, June 9, 2010

The BeagleTouch is an Open Source Hardware Module for the BeagleBoard. It’s inspired by concepts of modularity and rapid proto-typing, and continues Liquidware’s expansion into higher performance open source hardware.
Matt and I lined up one of almost every major modular gadget platform that he, Chris, Mike, and I have made over the past 2 years in one spot on the table. We called it “The evolution of Liquidware’s modular gadgets” and in tribute, found an old copy of Stephen Hawking’s A Brief History of Time.

 
First there was the Arduino and the TouchShield Stealth. This combination let anyone with an Atmel 168-powered Arduino Diecimila make small, handheld, portable, self-contained gadgets.
 
Then came the TouchShield Slide, for programmers with more demanding applications who wanted larger screen real estate, and a more accurate touchscreen to pair with the more powerful Arduino Duemilanove. The TouchShield Slide was featured on TV in NYC, used by celebrities, hacked by NASA, used for industrial design, and for rapid prototyping by the Department of Defense (no joke, they’re probably reading this right now and shaking their heads tsk tsk). The TouchShield Slide let the Arduino run Mario, and it has its own open source operating system, Pyxis, and a lightweight port of a small MacOS by Mark.
 
Then there was what Eric von Hippel would call “architectural innovation”, which is where the same modules are used over and over, but the architecture and the substrate changes and morphs as the modules are reconfigured into new setups.
This is the Arduino Gameboy Gamepack with an Arduino Duemilanove, Lithium Backpack, Doublewide Extendershield, Touchshield Slide, and Inputshield.
 
Here’s a picture of the Arduino Mega and the Mega Backpack with a TouchShield Slide:

Then there was the TripleWide Extender, which I used for the open source calculator project:
  
And now… hot on the tails of Apple’s announcement of the newest iPhone v4, Justin, Chris, Mike, Paul, and I present the new Open Source Hardware, modular BeagleTouch:

The BeagleTouch is a open source hardware modular screen, which snaps onto the BeagleBoard, and lets someone build and prototype handheld Linux gadgets.

Tuesday, June 8, 2010

DIY Gadgets with the BeagleBoard

Matt and I have been building Arduino gadgets with shields for the past year or so. What I really like about the Arduino is that it has a standard pin header layout, which literally made DIY modular gadgets a snap:

Looking at the BeagleBoard, however, it's not as obvious how to snap it all together.
So I figured I would do a quick walkthrough of how to put together a DIY BeagleBoard gadget.
Step 1: Gather modules for the Beagle Gadget
One of the setups most folks used was a portable handheld display. It was a TouchShield Slide touchscreen on an Arduino Duemilanove, powered by a Lithium Backpack battery. Then it was just a matter of uploading different apps, menus, or pictures to the device.
To make something similar for the BeagleBoard, I grabbed my BeagleTouch display, BeagleBoard, and BeagleJuice battery pack, and my pre-formatted Liquidware BeagleBoard Linux boot SD card.

Step 2: Solder on pin headers to the BeagleBoard
The BeagleBoard has quite a few expansion headers - much like the Arduino. But unlike the Arduino, the standard BeagleBoard comes with the headers unpopulated, and most people just put on the headers that they'll need or think they'll be using.

The BeagleTouch comes with a few extra headers that go onto the BeagleBoard, which I've soldered on like this:
 
Step 3: Mount the BeagleBoard on the BeagleJuice battery
Since the BeagleJuice only needs to plug into the BeagleBoard's power jack, I'm securing it to the backside of the BeagleBoard. Like with the Arduino's Lithium Backpack, I'm using some plastic screws and standoffs that came with the BeagleJuice.
 
Step 4: Snap the BeagleTouch on the BeagleBoard and BeagleJuice
Now that I've added the expansion pin headers to the BeagleBoard, the BeagleTouch can snap right on. The back of the BeagleTouch also has female headers that connect to the BeagleBoard's serial pins, so I can talk to the entire setup over USB from my Linux laptop.
 
Step 5: Power up and boot!
I've plugged in the BeagleJuice battery to the power jack, and I put the boot SD card into the BeagleBoard.
 

It's all ready to go, so now I just switch the power on, and Liquidware Beagle Linux boots up!

I've put everything I used in this tutorial over at the Liquidware shop, under Beagle Embedded Starter Kit. And here's a video demo of the Beagle gadget that Matt and I put together:

BeagleBoard Hello World

This is a BeagleBoard.


This is a BeagleBoard on drugs.
What a shame.
This is an SD card, specifically formatted by me and Chris using a ridiculously long, arduous process of trial and error before we finally figured out how to format it using a custom, homebrew version of Angstrom Linux.
This is that same SD card, on drugs.
Yeah, now the joke is getting old.
The SD card is formatted (it’s available at the Liquidware shop pre-set up) with Liquidware BeagleBoard Linux, which is guaranteed to work (as opposed to the other flavors that are floating around that are guaranteed to take about 6 hours to get up and running). All the code is over at github:
http://github.com/liquidware/liquidware_beagleboard_linux
You can download it with the command:
git clone git://github.com/liquidware/liquidware_beagleboard_linux.git
cd liquidware_beagleboard_linux
git checkout liquidware
If you have an SD card already pre-formatted (e.g. because I gave you one at Maker Faire, or because it came with the BeagleBoard Starter Kit), plug it into the SD card slot on the BeagleBoard:

Then plug in the USB-to-serial cable crossover cable – this is a cable that specifically lets you plug in the BeagleBoard to the computer, and access it and program it over serial. It is deceiving, because it looks like a normal USB-to-serial cable setup, except that it needs a gender changer (there are so many jokes I could make right now but won’t) in order to swap Rx and Tx wires. I figured this out the hard way early on, when I had to solder up my own cable.

Then, plug the power cable into the BeagleBoard to power it on.

To see the BeagleBoard status and command line prompt over serial, type the following command into Linux:
screen /dev/ttyUSB0 115200
 
That will open a serial terminal monitor on Linux, and on Ubuntu (which is what I run), it is at the dev/ttyUSB0 port. The speed is 115200. If you’re on Windows, just open a terminal program and select the USB port you want, and set the speed to 115200. Voila. After a short while, you’ll see the BeagleBoard booting up, and then you’ll see a command line prompt:

Angstrom Linux!
Ok, now you’re up and running!

Monday, May 31, 2010

Up and running on the Humidity Sensor

Mike, Matt and I had a blast out at the Bay Area Maker Faire in San Mateo last week. It was great to put some faces to names, and talk to fellow hackers in person.

I had a couple folks asking about their Arduino greenhouse projects, and they mentioned it might be useful to have a humidity sensor to make sure the room didn’t get too dry.

So Paul and Chris built the Humidity Sensor, which is really a Humidity and Temperature Sensor, since it provides an integrated temperature reading as well. I’ve uploaded it over at the Liquidware  and Modern Device shop pages.

The Humidity (and Temperature) Sensor is a board that carries the SHT21 digital humidity and temperature sensor from Sensirion. It has 4 pins that can mount directly on the Arduino’s analog pins. Two of the four pins are Ground and +5V; the other two are clock and data pins making up the 2-wire serial interface.

It transmits data to the Arduino over an I2C protocol, and comes with built-in 5V tolerance to be powered directly from the analog pins. The Antipasto Arduino IDE has an integrated library that makes the humidity sensor plug-and-play.

Here’s a quick demo that Will and I put together, which maps out the relative humidity and temperature as a bargraph on the TouchShield Slide. Because the Slide doesn’t occupy any of the Arduino Duemilanove’s analog pins, I was able to mount both the Humidity Sensor and the Slide directly onto the Arduino.

I took a video of the Humidity Sensor bargraphs in action:

And the code is below:

//Humidity sensor bar graphs - Arduino Code
#include
#include
#include
int h;
int t;

LibHumidity humidity = LibHumidity(0);

void setup() {
  Sensor.begin(19200);
}

void loop() {
h = (int)humidity.GetHumidity();
t = (int)humidity.GetTemperature();
Sensor.print("humidity", h);
Sensor.print("temp", t);
delay(5);
}

________________________________________________

//Humidity sensor bar graphs - TouchShield Code
#include
int newT;

void setup() {
  Sensor.begin(19200);
  background(0);
  line(0, 120, 320, 120);
text("RHumidity:", 0, 50);
text("Fahrenheit:", 0, 140);
}

void loop() {
if (Sensor.available()) {
   int h;
   int t;
if (!strcmp(Sensor.getName(), "humidity")) { 
h = Sensor.read();

fill(0);
text(h, 230, 80);
delay(10);
fill(0);
rect(0, 70, 200, 30);
{
fill(0, 0, 255);
rect(0, 70, h*2, 30);
}
}

if (!strcmp(Sensor.getName(), "temp")) { 
t = Sensor.read();

//convert celcius to fahrenheit
newT = (t*1.8 + 32);

fill(0);
text(newT, 230, 170);
delay(10);
fill(0);
rect(0, 160, 200, 30);
{
fill(255, 0, 0);
rect(0, 160, newT*1.6, 30);
   }
  }
}
}

Will’s posted the PDF cheatsheet over here, and I’ll be starting a greenhouse project next week with a couple of Arduino sensors including this one, so I’d love to hear any advice from any hackers out there with a green thumb :)

3-axis CNC Milling Machine

David Carr

My final project is a 3-axis CNC milling machine that costs less than $100 (currently $87) to build. It can mill PCBs, wood, and even mild steel.
 

These PCBs were milled using the machine. The traces are 10-15 mils. The left and lower right boards were milled at approximately the same speed as the Modela. The upper right board was milled at a speed approximately 50% higher than that of the Modella. This possible in part due to the Mantis MTM's increased spindle speed, about 20,000 rpm.
 

Some more test pieces: MDO and mild steel with a 1/32 inch mill on the left, wax with a 1/8 mill on the right. 

Design

My design was heavily influnced by Johnathan Ward's MTM-AZ, although it shares no common parts with his machine. It has a MDO framework that supports an overhead Y,Z zxis gantry above the bed (X axis). All three axes ride on precision steel rods and are manipulated by stepper driven lead screws. The working volume is currently 6x4x1.25 inches. 

Machine drawings (DXF)
Bill of materials

Brute force stepper driver

The brute force stepper driver is a simple 3 axis stepper driver for use with EMC2. To use it you need a real parallel port (not a USB one). Also beware of parallel ports that only produce 3.3V rather than the full 5V.

Here are the files for milling the board:
Bottom (PNG)
Holes (PNG)

Mill the first/bottom layer with a 1/64 inch mill first. Then without touching the board, mill the holes layer with a 1/32 inch mill. Use Z = -.066 for the holes layer and speeds of .5/.5.


Components

• MDO frame
• Y,Z axis gantry assembly
• Bed and X axis assembly
• Spindle assembly
• Stepper motor drive board
• PC control software

Processes

All of the machine's structure is MDO and is designed to be milled on the ShopBot. The leadscrews and leadscrew nuts require drilling and tapping operations that are preferrably perfomed on a lathe. The stepper motor drive board must be assembled and integrated with the control software. The remainder of the assembly tasks are designed to be completed with hand tools.

Schedule

Design prototype (complete)
Machine first prototype "kit" (complete)
Assemble prototype (completed)
Revise design (completed)
Design control board (complted)
Construct control board (completed)
Machine next iteration (completed)
Assemble next iteration (completed)
Integrate control software (completed)
Revise design (completed)
Present machine (completed)

Over and out.

The mini flying robot drones that join forces before takeoff - all without human help

Mail Online

By Niall Firth

Last updated at 10:57 AM on 9th June 2010

It conjures up a rather frightening vision of a future where intelligent robots work in packs without the need for human intervention.

But scientists are developing robots which can 'dock' with each other  and fly together in a swarm.

Using infrared beams the drones are able to find each others' location and connect with one another using magnets, completely autonomously.

The four drones takeoff under their own power and exchange information using infrared

The individual vehicles - or quadrocopters - have fixed propellers that can lift them into the air, but the resulting flight is erratic and uncontrolled.

But once they are joined together these relatively simple little robots evolve into a sophisticated multi-propeller system capable of coordinated flight.

Each helicopter unit has its own motor, computer, and sensors.

As well as a mini-propellor duct system for flying they also have little wheels underneath to let them crawl around the ground and find each other.

The group is able to keep itself level by using altitude sensors in each robot which speak to each other using infrared to make sure the flight is even.

Even if one of the robots in the swarm fails, the others are able to reposition themselves to keep the aircraft flying.

The exciting breakthrough is being developed by researches at the Swiss Institute of Technology in Zurich.

The self-contained modules can join together for take-off before separating to continue on the ground

The robots exchange information and combine this with their own sensor measurements to determine how much thrust is needed for take-off.

When the flight is over, the robots are able to simply detach their magnetic docking system and separate and drop to the ground where they can drive away.

Even if the robots were attacked they are able to detach from each other and then find one another and reform on the ground.

If the array’s level flight is disturbed, each vehicle individually determines the amount of thrust required to correct for the disturbance based on its own position.

While it is only a research project at the moment the 'Distributed Flight Array' can, in theory, be scaled up to contain any number of individual robots.

The system would be extremely useful for carrying large loads that are too heavy for individual robots.

NXT Mindstorms Walking Robot Biped - Pinocchio