Beagle Pilgrimage

I’ve be playing with the BeagleBoard for a couple of months now. It
looks like a real nice platform for teaching embedded processors. We
already have a class that teaches 8-bit embedded. We use PIC
processors and they are great for reading switches, turning LEDs on
and off and running motors, etc. The Beagle opens up whole new worlds
of streaming video, robot vision, etc. to my students.

The biggest challenge with the Beagle is deciding what to teach.
There is so much to choose from. So many paths to follow. Below is
my Beagle Pilgrimage. It’s the steps I’m taking to learn all I can
about the Beagle. Some day it may be the path I’ll lead my students
down. Or, if I turn this into a workshop, lead other faculty down.

The reason for posting here is to get feedback from the group.
• Is this a reasonable path?
• Have I missed something?
• Should I skip something?
• Is the order correct? My approach is the get them up and running
first, then later go back and look at some of the details on how thing
work. This is why, for example, boot details appear late in the

Topic Details
First Layer - Running the Beagle via Angstrom
Getting Started Gathering the hardware that is needed. Formatting the
SD card. Copying an image to the SD card and booting.
Learning where to find resources online.
Getting Around Learning various Linux commands. Using opkg to update
and install new software. Boot arguments. Changing screen
resolution. Demos of VNC, synergy, openCV, mplayer, GStreamer.
Building your first image via the web Using narcissus (http:// What to include, what
not to.
Installing the OpenEmbedded development environment Build your own
image on your own computer. What and how to include modules. How to
use other’s kernel patches.

Second Layer - Developing on the Beagle
Developing code, debugging, measuring performance “Hello World”.
Development tools. Measuring and improving performance. Talking to
hardware devices (I2C, SPI, etc.). Creating your own kernel module.
Using SVN.
Improving performance via NEON Using the ARM’s NEON SIMD extensions to
improve performance
Boot details What happens when the power is first turned on. MLO,
uImage, etc.
How displays are handled DSS2. Frame buffers, overlays. DVI, S-Video,
GStreamer Using GStreamer for multimedia

Third Layer - Developing for the advanced hardware.
Programming the DSP The CCS environment. DSP Bridge. Using DSP
binaries from TI.

Hi Mark,

Sounds like a great schedule. I would exchange the order of teaching the DSP
compared to the NEON and SIMD stuff. I think the general knowledge of
multi-core systems is more valuable than the specifics around NEON and SIMD.

The guys who would really like to know Cortex A8 and NEON in depth will
sneak into this anyway. In my opinion it's harder to begin playing with
multi-core and IPC on your own than adding NEON and SIMD knowledge on top of
an general ARMv5-course...

Similar goes for the complete understanding of TI Codec Engine, XDM, etc...

Best regards - Good luck

  Good suggestion. I presently don't see much work on the DSP side.
Maybe I can pull together a couple of simple examples of using the DSP
and that will lower the activation level for others.

My thesis work (some 25+ years ago) had to do with mapping speech
processing algorithms to SIMD architectures. Therefore I'd like to
see how NEON does it. Little did I know back then that people would
own SIMD machines and not even know it!