BeagleBone announcement

There's a new dog in the pack! The BeagleBone was announced
yesterday. For those of you hanging out at
http://beagleboard.org/chat, you've probably been hearing about it for
about a month. It is real, but there are still very few of them out
there. I am mailing some A2 boards out to some key
partners/developers now, but the production version, A3, is going
straight to ramp-mode. The only difference is a change in the
Ethernet PHY to improve the throughput, which we are now quite happy
with how it is getting around 95Mbps under iperf.

The BeagleBone schematics and BOM are now up on
http://beagleboard.org/hardware/design. The system reference manual
and other docs should be showing up later this week.

The page for updates is http://beagleboard.org/bone. I'll try to get
a blog post out later today as well, but no promises there. Other
people's posts seem to be telling most of the news anyway. For those
of you too lazy to bring up a browser window, here are the current
contents of http://beagleboard.org/bone (without all of the links,
videos or pictures):

===What is the BeagleBone?===
The BeagleBone is the low-cost, high-expansion hardware-hacker focused
BeagleBoard. It is a bare-bones BeagleBoard that acts as a USB or
Ethernet connected expansion companion for your current BeagleBoard
and BeagleBoard-xM or works stand-alone. The BeagleBone is small even
by BeagleBoard standards and with the high-performance ARM
capabilities you expect from a BeagleBoard, the BeagleBone brings
full-featured Linux to places it has never gone before.

===How can I buy one?===
Distributors are coming on-line now and enabling pre-orders. Boards
should ship to distributors before the end of November. Find the
currently on-line distributors at http://beagleboard.org/buy.

===What is the BeagleBone capable of doing?===
At over 1.5 billion Dhrystone operations per second and vector
floating point arithmetic operations, the BeagleBone is capable of not
just interfacing to all of your robotics motor drivers, location or
pressure sensors and 2D or 3D cameras, but also running OpenCV, OpenNI
and other image collection and analysis software to recognize the
objects around your robot and the gestures you might make to control
it. Through HDMI, VGA or LCD expansion boards, it is capable of
decoding and displaying mutliple video formats utilizing a completely
open source software stack and synchronizing playback over Ethernet or
USB with other BeagleBoards to create massive video walls. If what you
are into is building 3D printers, then the BeagleBone has the
extensive PWM capabilities, the on-chip Ethernet and the 3D rendering
and manipulation capabilities all help you eliminate both your
underpowered microcontroller-based controller board as well as that PC
from your basement.

===What are the detailed hardware specifications?===
Keep coming back! These will be updated soon. Some additional details
are in the latest BeagleBoard.org flyer.

Board size: 3.4" x 2.1"
Shipped with 2GB microSD card with the Angstrom Distribution with
node.js and Cloud9 IDE
Single cable development environment with built-in FTDI-based
serial/JTAG and on-board hub to give the same cable simultaneous
access to a USB device port on the target processor
Industry standard 3.3V I/Os on the expansion headers with easy-to-use
0.1" spacing
On-chip Ethernet, not off of USB
Easier to clone thanks to larger pitch on BGA devices (0.8mm vs.
0.4mm), no package-on-package memories, standard DDR2 vs. LPDDR,
integrated USB PHYs and more.
Where are the design materials?
These are still being updated ahead of boards shipping, but you can
find the latest versions always on the BeagleBoard.org Hardware Design
Page.

===How does Linux make the BeagleBone easier to use than a
microcontroller-based platform?===
The advantage of full-featured Linux is the Linux community. While the
template-based coding of systems like the Arduino make it easy to
copy-and-paste simple projects and a limited number of more complex
libraries that don't have a lot of interaction, 20 years of Linux
development have generated an extensive set of highly interoperable
software that can be utilized and collaborated upon, without
sacrificing the simplicity of doing something like toggling an LED or
switch or reading an analog or I2C-based sensor.

The first example I have is node.js, the server-side JavaScript
language interpreter with a rapidly growing community. The evented I/O
model enables both building highly scalable web servers and being
responsive to the many sensors within your embedded system. As part of
the shipping image with the BeagleBone, we are looking to provide the
git-enabled Cloud9 IDE that allows you to edit node.js applications
directly over your web browser by simply pointing it to the
BeagleBone. While this technology will be in a highly-alpha quality
state intended to communicate the possibilities for making a quantum
jump in rapid prototyping with Linux when the BeagleBone is initially
launched, we intend to collaborate with the Linux, Cloud9 IDE
(Ajax.org), node.js, github.com and BeagleBoard communities to evolve
this to Arduino-like simplicity, without the need to install any
development tools or understand Linux programming details. Development
of the application library will be done entirely in the open and is
awaiting launch until there is broad availability of the hardware to
avoid any undue refactoring that might come from not having the proper
collaboration and review.

===How does the BeagleBone compare to the current BeagleBoard or
BeagleBoard-xM?===
The BeagleBoard-xM is still the extra MIPS and extra memory
BeagleBoard with the greatest USB host expansion capabilities. If the
original BeagleBoard has all the horsepower and USB host capabilities
you need, but what you really want is easier and more extensive
expansion, on-chip Ethernet, analog-to-digital data conversion and a
lower cost, then the BeagleBone is the BeagleBoard for you.

===What does this mean for the future of the BeagleBoard and the
BeagleBoard-xM?===
The BeagleBoard and BeagleBoard-xM will continue to be manufactured
and available for purchase for several years to come (no end of life
in sight). We can be confident of this thanks to TI's commitment to
having parts availability for 10+ years for the key components. There
have been instances where we've needed to update non-TI components on
the BeagleBoard, such as the recent upgrade from 256MB of NAND flash
on the BeagleBoard to 512MB due to the end-of-life of the memory
device. We believe the upgrade shows our commitment to continued
production and support of the existing platforms.

===When will the BeagleBone be available?===
Some distributors are taking orders now. Rev A2 boards are just
shipping to active community members now. Rev A3 boards (production
version) will start shipping to distributors before the end of
November.

===How much will the BeagleBone cost?===
That is ultimately up to the distributors, but the suggested retail
price is $89. I am confident this will give some room for people
wanting to make clones can do so at a very competitive cost. The
AM335x has been announced to be available for as little as $5.

===Is this just a TI marketing gimmick?===
It is certainly not a marketing gimmick for the key leaders of the
project. We really do care about giving to the open hardware movement
and the projects it enables us to do personally and through
electronics education.

Several semiconductor manufacturers are attempting to duplicate the
community building success of the BeagleBoard and have cut the price
on their development tools, even to the point of giving away chips and
subsidizing the cost of other components on the board. Ultimately, I
think this is a good thing for developers who are aware of this by
lowering the cost of evaluating processor technology. However, for
those of us who feel personally responsible for the BeagleBoard, we
feel it is different than virtually all of those other efforts and
that it must stand on the quality of the technology and our commitment
to be a part of the BeagleBoard community, actively supporting
newcomers who seek to take ownership of the direction of the project.
We are personally excited about what we can do with the BeagleBoard
and would do it even if TI didn't pay us for it (and not all of us are
paid by TI, even though I am).

The current open hardware movement is much akin to early home computer
and radio hobbyist activities in its highly collaborative nature. We
aren't anti-competitive or looking to use our admittedly unfair
advantage of working closely with TI. Arduinos are great for what they
do, as are any number of ARM and non-ARM based embedded development
systems. To that end, we won't accept subsidies from TI on chips,
though we do get volume pricing that other solutions selling the
volume of the BeagleBoard and fostering open development would be able
to get. We have had challenges with some small groups trying to get
similar pricing, but believe we have resolved this at every turn. We
are committed to advancing open hardware for the benefit of all and
are seeking to enable new things with the BeagleBoard and BeagleBone,
not degrade or discount the great contributions to open hardware that
have come before or will come after.

===Why aren't the BeagleBone expansion headers compatible with the Arduino?===
We set out to enable something different than the Arduino, though
certainly having the breadth of add-on boards available to the Arduino
is in our goals. While it would have been possible to make this happen
and it is still possible to make an add-on board that would adapt to
that interface, the performance and cost of interfacing to Arduino
shields as-is would under-utilize the capabilities of the underlying
Linux-based system and compete in places where an Arduino is really
the right solution.

We are anxious to work with open hardware partners looking to generate
and sell add-on boards and microSD card images (or Linux kernel
patches or node.js libraries) that make hardware support transparent.
Availability on the BeagleBone will be at least as high as the current
BeagleBoard and BeagleBoard-xM, so the audience for your add-on
hardware will be extensive. Direct links on the BeagleBone purchase
page are welcome, as long as the key Linux distribution and hardware
test developers are provided with early hardware to ensure quality
interoperability. Open software collaboration through the BeagleBoard
mailing list is highly encouraged.

===What are the export restrictions?===
I will find out, but they will be similar to the original BeagleBoard
and BeagleBoard-xM.

===What is the processor used in the board?===
The BeagleBone uses a TI AM3358 ARM Cortex-A8-based microprocessor.
Announced on Oct 31, 2011, the main processor is available for as
little as $5, uses a 0.8mm ball-grid array and standard DDR2 memory,
making this board easier to clone than other BeagleBoard designs.

===Is there a road-map for peripheral boards?===
A DVI-D board is in the prototype phase right now. HDMI, VGA and LCD
boards will follow.

Plans for a Wi-Fi+Battery board are still in the very preliminary
phases. We've engaged several open hardware developers for sensor and
other interesting peripheral boards, but no hard commitments for a
roadmap yet. We are in the very early life of the BeagleBone and I
expect to see more available "sheilds", "capes", "peripheral boards"
or whatever you want to call them than you can count!

===If I want to make a "cape", is there a starting point?===
A community member has already started creating a starting reference
in Eagle. More on that to come.

We'll generally refer to them as "capes" because Underdog is a beagle
and he wears a cape. The term "shields" is nice, but that has some
implication of Arduino and this is definitely not an Arduino clone.

===Is this board a stand-alone board or is it supposed to be used in
conjunction with the BeagleBoard-XM? What capabilities does it add to
the BeagleBoard-XM if it does?===
Both. Because it doesn't have a display interface of its own, it needs
an external control terminal either over USB or over the network. A
BeagleBoard-xM may be used as a host, plus it build on the same Linux
distribution that ships with the BeagleBoard-xM for a large amount of
similarity. It would add extensive 3.3V I/O capabilities to the
BeagleBoard-xM.

===What if I already have a JTAG-based debugger?===
There are pads on the bottom to solder-on a JTAG header. You'll need
to remove a few small resistors as well. The trade-off was made to
make it easy for those new to embedded systems to be able to use
hardware in-system debuggers, saving them from the need to purchase
something that likely would have cost them as much as the board.

===How do I get software to run on the BeagleBone?===
Many projects may eventually provide software images that can be run
on the BeagleBone. The boards will be shipping with a Cloud9 image
from the Angstrom Distribution. See
http://www.angstrom-distribution.org/demo/beaglebone.

===Where is the software source code?===
The image that ships with the BeagleBone comes from the Angstrom
Distribution and is built with OpenEmbedded. Instructions to download
and build the Angstrom Distribution are at
http://www.angstrom-distribution.org/building-angstrom. The image can
be built with 'MACHINE=beaglebone bitbake cloud9-image'.

===What if I just want the boot-loader and kernel sources?===
A bit closer to the final software freeze date (roughly Nov 7, 2011),
the source code will be available at http://github.com/beagleboard.
Until then, you can watch the TI trees on arago-project.org and, of
course, meta-ti.

This is already causing a buzz right across the SDR (Software Defined Radio) communities.
One post wondered if ... I quote:-

Jason Kridner wrote:

There's a new dog in the pack! The BeagleBone was announced

I, for one, welcome our new bony overlords

so this board runs linux, but it is also easily programmabel as a microcontroller, right?
what language is used for the microcontroller part?
coming from the Arduino, how would i for example integrate image recognition via OpenCV with controlling IO ports for a robotic application. One part is a Linux application, the other is my custom code, how do both communicate with each other?

I think this is a game changer and what i see so far i really love the concept. specially the onboard IDE is mindblowing. having said that as a hardcore Arduino user.

so this board runs linux, but it is also easily programmabel as a
microcontroller, right?

I wouldn't say it can be programmed as a microcontroller, per se, but
the concept is to provide libraries that look like Arduino libraries.
That software will be in the infant stages when the boards start
shipping in a week or two.

There is a processing element called a PRU. My plan is enable
multiple "loop" functions to be created and to perform introspection
on those loops to identify if the loop can be moved entirely to a PRU.
A PRU has a ultra-low-latency response to the GPIO pins connected to
it. Currently, a PRU can only be programmed in assembly and my
approach would simply to create assembly functions to satisfy the same
functionality as the JavaScript functions and to off-load the loop to
the PRU to provide hard-real-time performance transparently (and to
warn when something won't run on the PRU and to provide guidelines how
to get something to run on the PRU).

Right now, the challenge is to get the hardware out there, knowing
that the software is in sort of a pre-alpha state, and to work on it
together with others who might want to participate. I expect some
will be turned off by how unfinished the software is, but I hope
they'll come back when it is really done.

I expect a lot of platforms to be able to utilize the software once we
are finished.

what language is used for the microcontroller part?

I'm doing an implementation in JavaScript using node.js called
'bonescript' right now that can be edited from Cloud9 IDE. I know of
someone else doing an implementation in C/C++ and looking at the IDE
integration (into the Arduino IDE --- whereas I will eventually look
into integrating that environment into Cloud9 IDE).

coming from the Arduino, how would i for example integrate
image recognition via OpenCV with controlling IO ports for a robotic
application. One part is a Linux application, the other is my custom code,
how do both communicate with each other?

You have all the mechanisms of Linux to have them communicate.
Sockets. Files. D-bus. Library calls. For my JavaScript library,
I'll look to enable some functionality through JavaScript modules as
it becomes clear to me what functionality I need to expose. For the
guy doing the C/C++ libraries, I suspect it he'll add some default
libraries to his environment such that you can call OpenCV functions
directly and that he'd likely add some helper functions/classes. Both
of us will have open repositories and accept productive merge
requests.

I think this is a game changer and what i see so far i really love the
concept. specially the onboard IDE is mindblowing. having said that as a
hardcore Arduino user.

Thanks! I've really wanted to get it out there so that people realize
what is possible. This makes a great platform to demonstrate that.

Realy great idea!
It will be my next toy^Wtool :wink:

There is one thing, I don't like:
The Ethernet socket is located too close to the "line" of expansion
sockets (as I can see on BeagleBone photos).
This will bring some pain for cape designers and DIY makers, because
every cape will have to have additional cut in the pcb for ethernet
socket :expressionless:

All the rest seems to be SUPERB!

Yes, you can see that cut in action at http://www.flickr.com/photos/koenkooi/6301342037/in/photostream

regards,

Koen

That is why the cape has a notch in it. It acts a s a key to make sure the boards are not plugged in backwards. Yo uwill be able to learn mor eon this when I release the SRM on Monnday.

Gerald

That is why they are called capes!

Gerald

i think the cut is okay, all capes will just have it. it's also not a
big deal to get PCBs produced in those shapes.

are there any files available to start tinkering with some ideas for capes?

I’d like to know more about the PRU. Is this something that’s on the other Beagles?

–Mark

We are working on making those files available. It will be a few weeks before they are ready. The SRM wil have the dimensions on it.

Gerald

sorry what does SRM stand for? is that a file format?

Why not just use the longer pin headers like we do with the Arduino? That way you don't have to cut the PCB in weird shapes and you get more space for schtuff.

I'd like to know more about the PRU. Is this something that's on the other
Beagles?

PRU is new and, honestly, the software support will be immature for it
for a while. You can find it on the OMAP-L138 and AM1808 as well. I
have a roadmap to have support for it in bonescript by Summer.

System Reference Manual. It is a PDF document.

Gerald

It acts as a key. We have symmetrical connectors with no key to prevent a person from plugging in the board backwards.If someone wants to create a board with longer pins, then they may do so.

Gerald

While on the topic of headers, it looks to me like there's a serious
lack of return (ground) pins on the connectors.

I was looking at doing something with the LCD interface, and you have
24 high speed signals and clock all jammed into one header with two
ground pins at the other end. There are no source terminations on the
LCD lines. I expect if you try to run those directly to a typical
panel with a few inches of FPC tail or some cable, the signals are
going to look mighty bad by the time they cross a couple of
connectors, cable, and get to the receiver.

Ok. This is a good reason to have this notch :wink:

On th etopic of ground pins, if you look at the BeagleBoard and BeagleBoard-xm we have even less grounds. We have no issue driving LCDs in that configuration. We always add a buffer there as we have to do voltage level translation. On the BeagleBone, We have DVID board working today with a buffer and the source terminations on the DVI-D board. It looks very nice!

Gerald