eLinux.org - User contributions [en]

ECE497 Beagle Bone WiFi

2013-05-18T17:12:34Z

Yoder:

[[Category:ECE497Fall2012]]
{{YoderHead}}

This wiki is for anyone trying to use a WiFi adapter on the Beagle Bone. It is originally created by Michael Junge, EE senior at Rose-Hulman Institute of Technology, class of 2012. As new information is discovered please feel free to edit this wiki.

== Required Hardware ==
You will need a [http://www.adafruit.com/products/814 WiFi adapter] from Adafruit. (I had to buy mine, however as the class expands Dr. Yoder pay potentially have a few to hand out for experimentation.)

You will also need the A6 hardware version of the BeagleBone. This does not work with the A5 version. (again at a later date this may not be an issue)

You will finally need the A5 software version of Angstrom found from [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS EBC Exercise 03 Installing a Beagle OS]. Again make sure it is the A5 software, this does not work with the A6 Rev.

Finally you will need a 5V BeagleBone power supply. The power supply that comes with the Beagle XM Board is suffient as well.

== Required Package Updates ==
When installing packages do not have the WiFi adapter plugged in.

beagle$ '''opkg update'''
beagle$ '''opkg install linux-firmware-rtl8192cu'''
bealge$ '''opkg install wireless-tools'''

== Procedure for running WiFi ==
You must follow this procedure for enabling the WiFi.

1) Plug in the WiFi adapter (do not plug in an Ethernet cable, it may not work properly)

2) Plug in the usb and connect the BeagleBone to your laptop.

3) Plug in the power adapter for the BeagleBone

4) Connect to the BeagleBone either through screen command or the LAN set up by the usb
(for connecting through screen or LAN refer to: [http://elinux.org/EBC_Exercise_02_Out-of-the-Box,_Bone EBC Exercise 02 Out-of-the-Box, Bone])

5) Run these lines of code:

beagle$ '''ifconfig wlan0''' to see what wlan0 currently displays
beagle$ '''iwconfig wlan0''' to see if wlan0 is configured properly
beagle$ '''iwconfig wlan0 essid x''' x-your own personal ID
beagle$ '''iwconfig wlan0 password y''' y- your own personal password
beagle$ '''iwconfig wlan0''' to check if your essid and password are correct
beagle$ '''ifconfig wlan0 up''' to enable wlan0
beagle$ '''ifconfig wlan0 xxx.xxx.x.x''' set to your own private network, usually 192.168.1,x
beagle$ '''ping xxx.xxx.x.1''' to check if your wireless is working correctly
beagle$ '''ping google.com''' to check DNS and Ethernet, because of campus security I have not been able to access DNS

Here is my personal screenshot of being connected to my wireless router as noted by ''wlan0'' instead of ''eth0''. The BeagleBone code is in the white box. My laptop is in red. This screenshot shows WiFi works, however it can be a pain to set up.
[[File:ECE497 Bone WiFi.png|500px]]

== Closing Remarks ==
I have not been able to figure out how to connect to the campus network. I know it has to deal with wpa supplicant. However at this time, I have not done enough research into wpa supplicant to connect successfully.

{{YoderFoot}}

ECE497 Modifying Kernel Command Line Parameters

2013-05-18T17:11:01Z

Yoder:

[[Category:ECE497Spring2011]]
The Linux kernel is booted with a series of parameters known as the ''kernel command line''. On the BeagleBoard, the uBoot bootloader handles both the booting and the passing of parameters. A typical command line on the BeagleBoard might look something like this:

#console=ttyS2,115200n8 console=tty0 root=/dev/mmcblk0p2 rw rootwait

Modification of the kernel command line is necessary for things like:

[[ECE497_Tips_and_Tricks#Using_u-boot_to_specify_a_MAC_address_at_boot | Static MAC Addresses]] or

[[ECE497 Pico Projector | Using the TI Pico Projector]]

In order to edit the command line, we need to edit a few uBoot files.

== Modifying Boot.scr ==
When uBoot finishes its initilization phase, it looks for a file called boot.scr
This is a binary file which is read by uBoot before it loads uImage which allows us to modify environment variables such as 'bootargs' (the kernel command-line) before we boot.

=== Boot.cmd ===
Boot.cmd is the plain text, uncompiled version of boot.scr. A standard BeagleBoard boot.cmd might look like:

if fatload mmc 0 80200000 uImage
then
\techo ***** Kernel: /dev/mmcblk0p1/uImage *****
else
echo ***** Kernel: /dev/mtd3 *****
nand read 80200000 280000 400000
fi

echo ***** RootFS: /dev/mmcblk0p2 *****
setenv bootargs 'console=ttyS2,115200n8 console=tty0 ethaddr=01:2b:03:01:23:45 g_ether.host_addr=00:dc:c8:f7:75:05 g_ether.dev_addr=00:dd:dc:eb:6d:f1 root=/dev/mmcblk0p2 rw rootwait'

bootm 80200000

The key part of this file is the line
setenv bootargs 'console=ttyS2,115200n8 console=tty0 ...'

This is the kernel command line, any additional parameters added on this line will be passed to the kernel when it is booted.

=== Compiling with mkimage ===
Once the boot.cmd file has been authored, we need to compile it to produce a boot.scr file. This is done with the mkimage program.
On Ubuntu, this program is available through the package 'uboot-mkimage'. It should be similarly available for most distributions.

Once mkimage is installed, you'll want to run it on boot.cmd to create boot.scr:
mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n 'Execute uImage' -d boot.cmd boot.scr

=== Replacing the old boot.scr ===
Once the new boot.scr file has been created, place it in the root directory of the BeagleBoard's SD card (the same directory as uImage).

Next time you boot, the kernel will be passed your newly added parameters!

If you have ssh access to your BeagleBoard, you can install your newly created boot.scr with the following command:
scp boot.scr root@beagleboard:/media/mmcblk0p1/
just be sure to replace 'beagleboard' with your BeagleBoard's hostname or IP address

== User.scr ==
If the USER button is held while the BeagleBoard boots, uBoot will look for the file user.scr instead of boot.scr. This gives us the chance to boot the kernel with two different command lines (or even boot another kernel all together).

The process for modifying or creating a user.scr file is the same as boot.scr, just change the filename.

== Makefile version ==
In order to simplify this overly complex process, we can use a Makefile like the one below:

# Makefile to create boot.scr and user.scr for uBoot
#
# Author: Michael Lester

all: boot.scr user.scr

boot.scr: boot.cmd
mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n 'Execute uImage' -d boot.cmd boot.scr

user.scr: user.cmd
mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n 'Boot Ramdisk' -d user.cmd user.scr

install: boot.scr user.scr
scp *.scr root@beagleboard:/media/mmcblk0p1/

So, in order to compile both boot.cmd and user.cmd into .scr files and install them on the BeagleBoard, just run:
make && make install

ECE497 Networking over USB

2013-05-18T17:09:46Z

Yoder: This page was never finished

[[Category:RemoveMe]]
The Angstrom demo image for the beagleboard comes with USB networking support. The only thing you have to do is to enable it by issuing the following commands on your beagleboard via the terminal. Note: you can use your own MAC and IP addresses, but maintain consistency.

== Loading the Necessary Module ==

The 'g_ether' module handles networking over USB support. This module can be loaded in two different ways:

'''TODO''' fix the following note to point to the actual configuration option (use default configs)

'''Note''' make sure that the configuration option for the g_ether module is selected (either M or Y)

=== Compile the Module into the Kernel ===

=== Load the Module Dynamically ===
'''Optional''' if g_ether module not compiled into the kernel, we can load it dynamically as an external module:

#cd /lib/modules/2.6.29-omap1/kernel/drivers/usb/gadget
#modprobe g_ether host_addr=16:0F:15:5A:E1:21 dev_addr=16:0F:15:5A:E1:20

= Bringing Up the Interface =
== On the BeagleBoard ==
== On the Host ==

= Making it Better =
== Automatic SSH login ==

ECE497: How to edit the Matrix GUI

2013-05-18T17:07:59Z

Yoder:

[[Category:ECE497Winter1112]]

On the SPEd image, there is a launcher on the desktop that runs the Matrix GUI program, which is similar to the iPhone app chooser interface. It turns out that this program is just written in HTML, and is very easy to edit.

The matrix folder is located in /usr/share/matrix/. It has 3 subfolders: html, images, and xml. menu_main.html is the first screen you see when starting up, so is the logical place to start editing. The actual editing is very straightforward, even if you have no previous HTML experience. Just a couple tips: if you want your icon to link to another menu page, then I would suggest using menu_comingsoon.html as a template. If you just use your own HTML, and have no back button, or exit button, you will have to kill the application from the serial cable (which, by the way, can be done with: pkill matrix). Also, all the other icons are 96x96, but as far as I can tell, any size image works just fine - just keep in mind it will be squished into a 96x96 size space.

EBC Goals and Needs

2013-05-18T17:06:54Z

Yoder: I no longer need this page

[[Category:RemoveMe]]
{{YoderHead}}

== Class goals ==

* Understand how to work with the community
* What is different in embedded?
* Know how to use it like a microcontroller
** GPIO interrupts via blocking
* Various places where things get initialized and understanding the boot/run process
* Rebuild bootloader and kernel
* Create a minimal kernel module
* Do a project

== Class needs ==

* xM SD card image that's up to date with Bone A6 image.
* USB audio output via hub at same time as USB audio input via webcam
* I2C library for 8x8 LED display with good perfomance
* PRU examples

{{YoderFoot}}

ECE497 SPI Project

2013-05-18T16:21:36Z

Yoder: Removed grade. Moved to Fall2012

[[Category:ECE497Fall2012 |Project]]
Team members: [[user:Richarsm|Sean Richardson]], [[user:larmorgs|Greg Larmore]]

== Executive Summary ==

For this project we wanted to further improve documentation available for sysfs kernel drivers with the Beagle Bone. To do this we have interfaced an [http://adafruit.com/products/306 LED light strand] by Adafruit with a sysfs kernel driver utilizing SPI. In doing so we have created an easy to use interface to the light strand while also maximizing data throughput.

== Good Websites ==

[http://elinux.org/BeagleBoard/SPI BeagleBoard and SPI]

[http://www.xml.com/ldd/chapter/book/ O'Reilly Book on Linux Device Drivers]

[http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/samples/kobject/kset-example.c Kset example for sysfs driver]

[http://elk.informatik.fh-augsburg.de/pub/elinux/ngw100-docs/AVR32743/spi/spi_example.c Example SPI device driver]

[http://www.jumpnowtek.com/index.php?option=com_content&view=article&id=57&Itemid=62 Another example SPI device driver]

== More Good Websites ==

[http://www.loadyourself.com/linux/sample-linux-driver/ Example Kernel Driver (ioctl, no sysfs)]

[http://www.freesoftwaremagazine.com/articles/drivers_linux Kernel Driver Tutorial (no sysfs/ioctl)]

== Installation Instructions ==

All of these instructions are meant for the A6A BeagleBone running version 3.2.25+ of the kernel. Scripts and Makefiles expect that the kernel be located at <code>~/BeagleBoard/kernel/kernel</code>

Start by cloning the [https://github.com/larmoreg/FinalProject github] repository on both the bone and the host machine by running the following:

both$ '''git clone git@github.com:larmoreg/FinalProject'''

On the host machine, run the following:

host$ '''cd ~/FinalProject'''
host$ '''./setup.sh'''

Make sure you only do this once because it is adding on our modules to the Kconfig and Makefile in <code>~/BeagleBoard/kernel/kernel/driver/char</code>. The files are backed up in the same folder with <code>.orig</code> appended.

Next run the following on the host machine:

host$ '''make kernel'''

This will copy the files <code>example.c</code> and <code>lpd8806.c</code> into the <code>~/BeagleBoard/kernel/kernel/driver/char</code> directory, make the kernel, and then scp the files to the bone.

Moving over to the bone, run the following:

bone$ '''cd /lib/modules/3.2.25+'''
bone$ '''mv modules.dep.bin modules.dep.bin.orig'''

Next modify <code>modules.dep</code> to include <code>kernel/drivers/char/example.ko:</code> and <code>kernel/drivers/char/lpd8806.ko:</code>

Upon successful completion, you should be able to run the following:

bone$ '''modprobe example'''
bone$ '''modprobe lpd8806'''

== User Instructions ==

Run <code>dmesg</code> or <code>lsmod</code> to make sure the modules have loaded properly. You should now find two folders inside <code>/sys/firmware</code> called <code>example</code> and <code>lpd8806</code>. Feel free to play around in the example folder. If you go into this folder and then one folder further into device, you will find two files. The <code>test</code> file holds an unsigned integer, while the <code>data</code> file holds a string of length 10 (initially empty). You can read and write from these files as you would any other sysfs file.

Next we will hook up the LED strand. For this make sure the beagle is powered externally. The USB power supply does not have enough current to run the 5m strand at full brightness.

To get started hook up pins 30 (D12/SPI1_D1) and 31 (A13/SPI1_SCLK) to SPI data and SPI clock on the strand (see the silkscreen for guidance. Hook up the ground to ground (obviously), and the 5V wire on the strand to the 3.3V pin on the bone. Do not use the 5V pin on the bone or the suggested Adafruit 5V power supply directly connected to the strand without also adding logic level voltage shifters to the data and clock lines.

[[File:Bone_P9_pinout.jpg]]

You may need to modify your muxes (if they have been changed from the default). If so, do the following:
beagle$ '''echo 0 > /sys/kernel/debug/omap_mux/spi0_d1'''
beagle$ '''echo 0 > /sys/kernel/debug/omap_mux/spi0_scl'''

Now that the strand is hooked up, we can run the following:

bone$ '''cd /sys/firmware/lpd8806/device/'''
bone$ '''echo "127 127 127" > grb'''

You should see the first LED (closest to the bone) light up bright white. You can also do something like the following:

bone$ '''echo "127 0 0 0 127 0 0 0 127" > data'''

The <code>data</code> file is written directly out to the strand while the <code>grb</code> file treats the strand like a big shift register. Be careful with using <code>data</code>. Buffering problems can cause the kernel to seg fault or crash completely (see Future Work).

== Highlights ==

We have created a simple C example that uses this sysfs driver. You can run it by doing the following:

bone$ '''cd ~/FinalProject'''
bone$ '''make'''
bone$ '''./test'''

{{#ev:youtube|8d9n5QUyH38}}

The program shows the capabilities of the strand running in shift mode. Because of the nature of the strand's construction, it would be very simple to daisy chain many chains end to end. Also, the kset implementation means that we can have as many separate strands as there are SPI buses. Normally you could have even more, but the strand only runs 3 wire SPI (no chip select).

The speed is increased greatly when the strand is running in direct access mode by using the <code>data</code> file instead of the <code>grb</code> file. However, due to time limitations we were unable to debug the buffering issues. A good place for future work would be to figure out how the buffering problem can be alleviated.

== Theory of Operation ==

There are many layers to the implementation, so we will break them out into subsections.

=== Light Strand ===

The light strand uses the LPD8806 controller chip. Each chip controls the brightness of two 3 color GRB LEDs using PWM running at 1.2 MHz. SPI is used to communicate with the controller chips. The controller has its SPI bus rated somewhere around 20 MHz, but we are only running at 10 MHz. Each LED is 21-bit color, which leaves three bits available for latch control.

So, as you write color values out on the SPI, the first chip receives them. If the chip hasn't written a color to one of its to LEDs, it does so and thus ends the transmission. However, if it has already assigned a color to each LED then it passes the SPI along on a separate bus to the next chip. This is how the strand is able to be 5m and still run at 10 MHz.

It is still unknown how exactly the 3 latch bits are used (because the chip manufacturer has kept the interface a secret). However, if you write 6 bytes of "latch" the strand restarts at the beginning. Perhaps less bytes of "latch" can be sent and get the same effect, but due to time limitations we were unable to debug this completely. This is a simple place to start for future work.

=== SPI Bus ===

We use the default SPI controller to control the SPI lines. All we had to do is find what master is controlling the bus (2 in our case) and add a device. Initially, the SPI bus we want is being used by the default configuration of spidev. So, all we do is unregister the device from spidev and reregister it for our driver. There are a few things that go into the configuration of the device like speed, number of bits, chip select, and mode. Once these are set, you can add the device and it will then be associated with your driver.

=== Sysfs Kernel Driver ===

The sysfs kernel driver is based on the references above. It uses a kset to store kobjects (the basic building block of the kernel). Each kobject has associated with it certain attributes. These attributes are brought out to the user as files. When the files are read from or written to, the kernel calls back into the kobject's read/write routines. Here, we are able to decide which attribute is being addressed and manipulate the buffer as we see fit.

There are some alternative implementations to this that were looked into in addition to kset. The driver could have been implemented as a sysfs device driver instead of a kernel driver so that it shows up in <code>/sys/class</code> with everything else. Another option is that it could be implemented as a straight up device/kernel driver making it show up in <code>/dev</code> instead. There doesn't seem to be much of a difference though between these implementations as far as performance is concerned. However, finding where this driver fits best is another good place for future work.

== Work Breakdown ==

=== Sean Richardson ===
* Researched using SPI on the BeagleBone
* Debugged the LED strand (the first one we received was broken)
* Wrote code to interface with the strand using spidev
* Helped integrate the SPI interface into the sysfs driver

=== Greg Larmore ===
* Researched kernel drivers and sysfs
* Helped debug the LED strand
* Wrote example sysfs driver
* Integrated the SPI interface into the sysfs driver

== Future Work ==

While the strand works well as it is, there are some things that we would like to see looked into if there is future work on this project.

=== Latching and Controller Interface ===

According to Adafruit, the interface to this part has been reverse engineered. The one part that really remains unknown is how exactly the 3-bit control interface works for each LED. We were able to achieve a latching effect by sending 6 empty transmissions. The code in [github.com/adafruit/lpd8806 Adafruit's github] doesn't seem to be using this many latch transmissions.

=== Buffering Problem ===

There is a problem with buffered output going into the <code>data</code> file (because it is so big). When the output buffers it causes 2 sequential writes which weren't being handled well by the attribute's store function. This could be alleviated with a circular buffer and an index that can be controlled by the user, but really the driver should be able to handle this condition.

=== Sysfs File Location ===

The decision to have these drivers located in <code>/lib/modules/3.2.25+/kernel/drivers/char</code> and run out of <code>/sys/firmware</code> was pretty much arbitrary. It would be nice to do some research into how the kernel is supposed to be structured so that we can match it. This also applies to the example driver included in this project.

== Conclusions ==

In this project, we were able to get SPI (a lesser used interface on the bone) to work well with our LED strand. More impressively, we were able to interface with the SPI through a sysfs interface. In the process of developing this sysfs interface to the LED strand, we developed an example sysfs driver that can be used in future ECE497 classes. Lastly, we developed a sample application that uses this sysfs interface for our LED strand to show off the results.

ECE497 SLAM via ROS

2013-05-18T16:21:13Z

Yoder: Removed grade. Moved to Fall2012

[[Category:ECE497Fall2012 |Project]]
Team members: [[user:whiteer|Elias White]]

== Executive Summary ==

(This is a big project for one person. Let's talk about your progress today.)
In autonomous navigation understanding the robot's surrounding environment, as well as its position in this environment, is of paramount importance. This project attempts to leverage the open-source efforts resulting in simultaneous localization and mapping (SLAM) algorithms and use them, in collaboration with the Beagleboard -xm, to develop a 3-D model of the world surrounding the board as it moves through space. Obviously the more (quality) sensory data used in a SLAM algorithm the better the results, but at this time a camera will be the only sensor device, although there is the possibility of incorporating a gyroscope. A primary objective of this project is to test the feasibility of using the Beagleboard -xm as the "brain" for an autonomous quad-copter.


An Embedded version of Ubuntu has been successfully installed, and ROS has been installed on top of it. While I make my final SLAM algorithm decision there is nothing else that works.


Building the world model and localizing my self in it.



With this project I hope to provide a example for my Aerial-robotics team members to follow and a starting point that leads them to increasingly awesome aerial robotics projects.

== Installation Instructions ==



There are a few fairly large installs (embedded Ubuntu, ROS) required. I'll pretty up the procedure and put throw it up here when I think it is at its most painless.

(Do you have a git repository?)

== User Instructions ==


Pending...

== Highlights ==



While there are currently no highlights, this [http://www.youtube.com/watch?feature=player_embedded&v=IMSozUpFFkU video] provides an idea of what I would like to do, although the quality of their results is much higher than I am expecting to achieve.

(How much of what's in the video comes with ROS?)

== Theory of Operation ==


The operating system running on the -xm is an embedded version of Ubuntu 12.04. ROS (Robotic Operating System) is installed within this OS, providing hardware abstraction, device drivers, libraries, et cetera, that provide simplified control of the robot platform. OpenCV is embedded in ROS and is responsible for the robot's interpreting the data provided by the camera and constructing an accurate representation of the world. While I haven't yet made my final decision on which SLAM algorithm to use, I am leaning towards [http://www.openslam.org/gmapping.html GMapping].

== Work Breakdown ==



As a solo group I'll be the only one working on this project.

== Future Work ==


In order to improve performance once could bolster the sensory profile of the platform. Useful sensors include:
#Laser scanning range-finder
#IMU (Inertial measurement unit)
#Digital Compass
#GPS

The incorporation of the data gathered from these sensors will improve the robot's model of the world and decrease the uncertainty it has about its location in the model.

== Conclusions ==



Nothing yet.

ECE497 Project: XBee

2013-05-18T16:20:54Z

Yoder: Removed grade. Moved to Fall2012

[[Category:ECE497Fall2012 |Project]]
{{YoderHead}}

Team members: [[User:Shinnsm|Stephen Shinn]], [[User:Mmoravec|Matt Moravec]], [[User:Duganje|Josh Dugan]].

== Executive Summary ==

The XBee project involves taking two series-one XBee modules (Include a link to these) and interfacing them with the various sensors that have been documented in our ECE497 group. Our goal was to create wiki sections which expand on the sensors to include sample wireless communication documentation and source code.

We have successfully connected to the XBee radios from the Bones and sent data using the <code>/dev/ttyO</code> file system. We have also successfully done wireless implementations of the force sensitive resistor, the magnetometer, and the joystick alone a set of functions for expanding this to any sensor.

In conclusion, we're using XBee modules to communicate from one Bone to another. We have successfully communicated wirelessly with three sensors: the force sensitive resistor, magnetometer, and joystick. We hope that these instructions and code libraries are useful to hobbyists who wish to implement their own wireless solutions with the BeagleBone.

== General Installation Instructions ==

=== Hardware ===

The very first step is to solder your XBee module, see [http://www.ladyada.net/make/xbee/solder.html the instructions here]. Once the module is assembled, you may wire-up the XBee module to the BeagleBone's serial ports. The table below describes how to hook up the module to UART2 on the Bone:

{| class="wikitable" style="text-align:center;" width=300px
! align="center"| XBee
! Bone, P9 header
|-
|GND
|Ground, port 1
|-
|3V
|3.3V, port 3
|-
|TX
|RX, port 22
|-
|RX
|TX, port 21
|}

The image below shows the configuration:

[[File:XBeeBoneConnection.jpg|450px|XBee module connected to a BeagleBone.]]

=== Software ===

Our git repo for this project is available here: [https://github.com/duganje/ECE497_XBEE.git https://github.com/duganje/ECE497_XBEE.git]. To begin, run
beagle$ git clone https://github.com/duganje/ECE497_XBEE.git
to clone the repository. This contains three folders with examples of XBee implementation for specific sensors and <code>XBee.c</code>, which contains helper functions for using the XBee. You are now able to send data wirelessly using the <code>SendIntXbee()</code> and <code>ReceiveIntXbee()</code> functions after running <code>initializeXbee()</code>. Clone the repository on a separate BeagleBone and use the same functions to receive and reply data.


== 0.5" Force Sensitive Resistor ==

These instructions are for interfacing the [[SparkFun: 0.5" Force Sensitive Resistor|0.5" Force Sensitive Resistor]] with the XBee.

=== Required Items ===

*2 x [http://adafruit.com/products/513 BeagleBone]
*2 x [http://www.adafruit.com/products/128 XBee Module]
*2 x [http://www.adafruit.com/products/126 XBee Adaptor Kit]
*1 x [https://www.sparkfun.com/products/9375 0.5" Force Sensitive Resistor]
*1 x 27kΩ resistor

=== Hardware ===

First we will connect the force-sensitive resistor to the Bone (P9 header). A 27kΩ resistor is used to connect the 3.3V source (pin 3) from the Bone to one pin of the force-sensitive resistor. Then, the other pin of the force-sensitive resistor is connected to ground (pin 1). An analog pin (AIN) on the Bone connects to the node containing both resistors, and values can be read off of that AIN. AIN5 (pin 36) is being used to read values on the Bone.

Next we will connect the XBee module to the Bone. The table below describes the necessary wiring.

{| class="wikitable" style="text-align:center;" width=300px
! align="center"| XBee
! Bone, P9 header
|-
|GND
|Ground, port 1
|-
|3V
|3.3V, port 3
|-
|TX
|RX, port 22
|-
|RX
|TX, port 21
|}

With everything wired-up, your connections should match the image below. Click on the image to view the full resolution.

[[File:ForceResistorXBee.jpg|600px|Picture of connection|link=http://elinux.org/images/3/3b/ForceResistorXBee.jpg]]

=== Software ===

We're going to start with these two pieces of code as a reference and combine them:

*[https://github.com/shinnsm/ECE497/blob/master/MiniProject02/miniProj2.c Code to interface with the force sensitive resistor]
*[https://github.com/duganje/ECE497_XBEE/blob/master/XBee.c Code to interface with the XBee module]

Running the code for the force sensitive resistor produces a value from 0 to 4096 depending on how much pressure is applied to the resistor. The harder the resistor is squeezed, the lower this value is. On line 46 of the force sensitive resistor code, <code>analogValue</code> is constantly updated and stores this number.

The instructions now fork depending on whether you're setting up the sending XBee code or the receiving XBee code. When you're done you will have two C programs, one running on each Bone.

==== Sending ====

Start with the [https://github.com/shinnsm/ECE497/blob/master/MiniProject02/miniProj2.c resistor code] as a base and add the following include to the top of the file to add our XBee library (available [https://github.com/duganje/ECE497_XBEE here]):

#include "XBee.h"

Next, add a call to <code>initializeXbee()</code> in <code>main</code> of the resistor code before the while loop begins.

In the <code>while</code> loop after the value of <code>analogValue</code> is updated, add this line:

sendIntXbee(analogValue);

This will send the integer analog value to the receiving XBee. Now the number is constantly being sent in the while loop.

==== Receiving ====

Start with the [https://github.com/duganje/ECE497_XBEE/blob/master/XBee.c XBee code] as a base and create a <code>main</code> function. First in <code>main</code>, add a call to <code>initializeXbee()</code> to setup the Bone to use the module.

Next, add a while loop to <code>main</code> which continuously receives the integer analog value from the other Bone using the <code>receiveIntXbee()</code> function. Once the integer value is received, you're free to use that information for whatever purpose you wish. The example code below should give you an idea of how this is done:

<pre>void main(int argc, char **argv, char **envp) {
// Initialize XBee
initializeXbee();

// Keep going
while (1) {
int analogValue = receiveIntXbee();

// Do anything based on analog value
if (analogValue < 1000)
ButtonPressedFunction();
}
}</pre>

==== Sample ====

===== Required Items =====

* LED
* 220Ω resistor

===== Instructions =====

Based on the instructions above, I've created a sample set of programs. Using two Bones, the send program runs on one and the receive program runs on another. The "send" Bone includes an XBee module and the force sensitive resistor, [[ECE497 Project: XBee#Hardware 2|hooked-up as described here]]. The second Bone includes the XBee module hooked-up in the same way with the addition of an LED connected to pin 12 (GPIO1_28) of the Bone. Connect the ground pin of the LED to the Bone's ground (pin 1) using a 220Ω resistor.

Running both programs emulates the original function of the [https://github.com/shinnsm/ECE497/blob/master/MiniProject02/miniProj2.c force resistor sample code], the only difference being that the data is now sent wirelessly from one Bone to another.

*[https://github.com/duganje/ECE497_XBEE/blob/master/ForceResistor/sendResistor.c Send Program]
*[https://github.com/duganje/ECE497_XBEE/blob/master/ForceResistor/receiveResistor.c Receive Program]

To easily run the programs, follow these steps (you can skip the first step if you have already clone the repository):
beagle$ git clone https://github.com/duganje/ECE497_XBEE.git
beagle$ cd ECE497_XBEE
beagle$ cd ForceResistor
beagle$ make

This will create 2 executables: '''sendResistor''' and '''receiveResistor'''. Run the programs by running:

beagle$ ./sendResistor

on the Bone connected to the XBee and the force sensitive resistor and

beagle$ ./receiveResistor

on the Bone connected to the XBee and the LED.

You will then be able to squeeze the force sensitive resistor and see the LED light up on the other BeagleBone. We've created a [[ECE497 Project: XBee#Force Sensitive Resistor YouTube Demo|YouTube demo]] of this program in action.

== Wireless 2-Axis Thumb Joystick ==

These instructions are for interfacing the [[Adafruit: 2-Axis Thumb Joystick|2-Axis Thumb Joystick]] with the XBee. This application could be useful in a wireless controller setting.

=== Required Items ===

*2 X [http://adafruit.com/products/513 BeagleBone]
*2 X [http://www.adafruit.com/products/128 XBee Module]
*2 X [http://www.adafruit.com/products/126 XBee Adaptor Kit]
*1 X [[Adafruit: 2-Axis Thumb Joystick|2-Axis Thumb Joystick]]

=== BeagleBone Wiring Instructions ===

On your first BeagleBone, wire pins 36 and 38 to your two analog inputs. Wire the Beagle's 1.8V VCC output, pin 32, to the VCC input of the Joystick. Finally, wire the select GPIO signal to the GPIO_7 pin or pin 42.

Wire the XBee as shown in the table below:
{| class="wikitable" style="text-align:center;" width=300px
! align="center"| XBee
! Bone, P9 header
|-
|GND
|Ground, port 1
|-
|3V
|3.3V, port 3
|-
|TX
|RX, port 22
|-
|RX
|TX, port 21
|}

The pinout and visual implementation are shown below.

[[File:Bone_P9_pinout.jpg|x400px]] [[File:XBee_and_Adafruit_Joystick.jpg|x400px]]

On the second BeagleBone, wire the XBee exactly as the first XBee (as described in the table above).

Don't hook up any other hardware to the second XBee as it will be acting as an information hub.

=== Usage Instructions ===

On both BeagleBones, clone this repository: https://github.com/duganje/ECE497_XBEE.git
Use the following to run the joystick code (you can skip the first step if you have already cloned the repository):

beagle$ git clone https://github.com/duganje/ECE497_XBEE.git
beagle$ cd ECE497_XBEE
beagle$ cd 2AxisJoystick
beagle$ make

This will create 2 executables: '''joystickSend''' and '''joystickReceive'''. Run the code by doing:

beagle$ ./joystickSend

on the Bone connected to the XBee and the joystick and:

beagle$ ./joystickReceive

on the Bone connected to just the XBee.

== Magnetometer ==

These instructions are for interfacing the [[Sparkfun: HMC5883L Magnetometer|HMC5883L Magnetometer]] with the XBee.

=== Required Items ===

*2 x [http://adafruit.com/products/513 BeagleBone]
*2 x [http://www.adafruit.com/products/128 XBee Module]
*2 x [http://www.adafruit.com/products/126 XBee Adaptor Kit]
*1 x [https://www.sparkfun.com/products/10530? Magnetometer Breakout Board]
*2 x 4.7kΩ resistor

===Hardware===

The XBee radios should be connected to both Beagles as shown in the table below.

{| class="wikitable" style="text-align:center;" width=300px
! align="center"| XBee
! Bone, P9 header
|-
|GND
|Ground, port 1
|-
|3V
|3.3V, port 3
|-
|TX
|RX, port 22
|-
|RX
|TX, port 21
|}

The Magnetometer should be connected to one BeagleBone as described in the [[Sparkfun: HMC5883L Magnetometer|hardware]] section of the Magnetometer page. Ground and Vcc on the Magnetometer should be connected to pins 1 and 3 respectively on header P9 of the bone. SCL and SDA on the Magnetometer should be connected to pins 19 and 20 on P9 to use I2C bus 3. Two 4.7kΩ resistors should also be connected between SCL and Vcc and between SDA and Vcc. Below is a picture of the Beagle connected to the Magnetometer and the XBee.

[[File:XBEE_MAG.jpg|600px|Picture of connections]]

===Software===

The goal is to have the two BeagleBones attached to XBee radios with the one connected to the Magnetometer taking data and transmitting this data to the other Bone which will print the measured data.

I started with the code to collect data from the Magnetometer and the code to send data using the XBee radios. Here are the links to these two programs:
*[https://github.com/duganje/ECE497_duganje/blob/master/MiniProject02/miniproject02.c Code to gather magnetometer data]
*[https://github.com/duganje/ECE497_XBEE/blob/master/XBee.c Code to interface with the XBee module]

The code for the magnetometer uses I2C to read the values for the X, Y and Z-Axes and print these values to the terminal. The XBee code contains helper functions to transmit data wirelessly. I have written two programs: one to collect and transmit the magnetometer data and the other to receive and display this data.

====Sending====

*[https://github.com/duganje/ECE497_XBEE/blob/master/Magnetometer/sendMag.c Tranmitting Magnetometer Data Code]

The code uses [https://github.com/MarkAYoder/BeagleBoard-exercises/tree/master/i2c I2C code] from [[EBC Exercise 12 I2C]] and helper functions from [https://github.com/duganje/ECE497_XBEE/blob/master/XBee.c XBee.c].

The program uses:

i2cget(i2cbus, address, daddress);

to get the data from the magnetometer and

sendShortXbee(val);

to send these values to the receiving XBee.

====Receiving====

*[https://github.com/duganje/ECE497_XBEE/blob/master/Magnetometer/receiveMag.c Receiving Magnetometer Data Code]

The receiving code uses:

receiveShortXbee();

to read the values for each axis.

Because we do not have a way to synchronize the two XBees, the receiving program must be started first to ensure the data is receive in the correct order.

In the Highlights section, there is a video demo of the complete program.

===Running the Code===
Use the following to run the magnetometer code (you can skip the first step if you have already clone the repository):

beagle$ git clone https://github.com/duganje/ECE497_XBEE.git
beagle$ cd ECE497_XBEE
beagle$ cd Magnetometer
beagle$ make

This will create 2 executables: '''receiveMag''' and '''sendMag'''. Run the code by doing:

beagle$ ./sendMag

on the Bone connected to the XBee and the magnetometer and:

beagle$ ./receiveMag

on the Bone connected to just the XBee.

== General Usage ==

These instructions are a general how-to for using the XBee with any sensor.

After cloning our repository to your favorite location, include the necessary header file, <code>XBee.h</code>. In your <code>main.c</code> file or your program, first run: <pre>initializeXbee();</pre> which sets the pins we will need to communicate with the XBee using UART 2. Then in your <code>main.c</code> file, call: <pre>sendIntXbee(yourInt);</pre> with <code>yourInt</code> being any integer data you would like to transmit. On your 2nd BeagleBone, call: <pre>receiveIntXbee();</pre> which will return the integer which was sent through <code>sendIntXbee(int yourInt)</code> on the 1st board.

The send and receive functions can be easily modified to send any data type, as shown in <code>XBee.c</code> with the following functions:

<pre>sendShortXbee(short yourShort);</pre>
<pre>receiveShortXbee();</pre>

== Highlights ==

Our project is able to send and receive wireless data for a whole range of possible implementations. We've created YouTube demos for the three sensor implementations we've described so far:

=== Force Sensitive Resistor YouTube Demo ===
{{#ev:youtube|Ds_BWsrvy1I}}

=== 2-Axis Thumb Joystick YouTube Demo ===
{{#ev:youtube|9t1MQGYNOt4}}

=== Magnetometer YouTube Demo ===
{{#ev:youtube|99bFqE54UHM}}

== Theory of Operation ==

The main theory of operation is based on Linux's use of files. UART files on the Bone represent serial connections. With an XBee connected to the Bone's UART 2 as shown above, sent and received messages are written to <code>/dev/ttyO2</code> (the O is an uppercase O, not a zero). The BeagleBone's UARTs are accessed through <code>/dev/ttyO'''x'''</code>, where <code>'''x'''</code> is the UART number. Our code uses this and reads the file to receive a message and writes to the file to send a message. Any XBee's on the same network wil receive the message and we can do anything we want with it.

== Work Breakdown ==

=== Milestones ===

*Monday, 10/29 - XBee hardware received. (done)
*Thursday, 11/1 - XBee Bones are connected and commands can be sent. (done)
*Monday, 11/5 - Initial sensor implementation. (done)
*Thursday, 11/8 - Package language implemented between Bones. (done)
*Sunday, 11/11 - YouTube demo uploaded. (done)
*Monday, 11/12 - All documentation complete. (done)
*Tuesday, 11/13 - Everything complete & all code ''makes''. (done)

=== Completed Work ===

* Soldering XBee's - Matt Moravec
* Initial communication methods - Stephen Shinn
* Expanded communication methods - Josh Dugan
* Initialization method - Josh Dugan
* Force Sensitive Resistor implementation and demo - Stephen Shinn
* Magnetometer implementation and demo - Josh Dugan
* 2-Axis Thumb Joystick implementation and demo - Matt Moravec

== Future Work ==

The following are some additional things that could be done with this project:

* Create and document interfaces for more sensors
* Back-and-forth 2-sensor communication
* Create a practical application such as a wireless doorbell

== Conclusions ==

In conclusion, we created an XBee wireless communication library for BeagleBone and adapted three sensors to use it. We've also documented general usage instructions for adapting XBee to use any type of sensor. We have not found a comprehensive source for how to use XBee modules with the BeagleBone, so our code and instructions are online with the intention that others use them as a reference.

We were unable to get a working program with 2-way communication with 2 XBees each sending and receiving data because of synchronization problems. Addressing this would require the development of a communication protocol to prevent deadlocks and to ensure the receiving program knows what the data is when it receives it. This would be a logical next step in terms of future work for this project.

Using the wireless modules is interesting, and there is a number of things you can do with them. We've listed a few ideas above which could be done in the future. One interesting idea would be to create a practical XBee application that someone could actually use in their home or work life. With a few XBees around the house, one could have a small network for sending data and using a sensor to control Christmas lights or something.

{{YoderFoot}}

ECE497 Project: Kinect

2013-05-18T16:20:33Z

Yoder: Removed grade. Moved to Fall2012

[[Category:ECE497Fall2012 |Project]]

Team members: [[user:Astroricks|Yue Zhang]], [[user:Xinyu1991|Xinyu Cheng]], [[user:Lix|Xia Li]].

== Executive Summary ==

I believe that almost every college students have played a game called "Greedy Snake" in our childhood. At that time, we played it on the cellphone, on the computer or on the PSP. However, we are always using the keyboard to control the games we played. Now, our final project could bring you something new, that is a "Gesture Controlled Greedy Snake". It means that, using the gesture, the keyboard is never required to play the game. Amazing? Read the following wiki to know how we make it happens!

Basically, we are using the Kinect from Microsoft and the Beagle Board XM from Texas Instrument to accomplish our gesture game. The program for the game is programmed on the QT-Linux. Besides, we use the cross compiling to compile the program to make the game run on the beagle board.

After our previous work, our "Gesture Greedy Snake" is completed, and works pretty good. The snake can be controlled by our gestures smoothly. The game reminds us a different style of childhood memory.

== Installation Instructions ==

=== Hardware ===

1 x [http://www.microsoftstore.com/store/msstore/en_US/pd/ThemeID.27509700/Kinect-for-Xbox-360/productID.216507400 Kinect]

1 x [http://www.digikey.com/product-highlights/us/en/texas-instruments-beagleboard/685 BeagleBoard xM]

1 x DVI to HDMI wire

1 x Monitor

1 x Keyboard

1 x Mouse

=== Software ===

==== Overview ====
The source files for the project can be downloaded from https://github.com/Astroricks/Snake-Game-with-Kinect-on-BeagleBoard-xM . Once you have set up the developing environment as in the following instructions, you can download the files, playing with the game or making changes.

We are using the drivers provided by [http://www.omekinteractive.com/ Omek]. The driver files can be found at the Beckon™ SDK 2.4 – BeagleBoard-xM Edition [http://support.omekinteractive.com/index.php?/TI/managedownloads/Download/View/32/11/installation installation] page, and a developer's guide is provided at the [http://support.omekinteractive.com/index.php?/TI/managedownloads/Download/View/34/11/documentation documentation] page. (You may need to register first.) Instructions in this [http://treyweaver.blogspot.com/2010/10/setting-up-qt-development-environment.html blog] are also very useful.

Although the developer's guide introduces how to do the installation and configuration, we have found that it takes much longer than we originally thought, and errors came out occasionally. It seems that the developer's guide is not very well organized and not detailed enought anyway. So we arranged our instruction and configuration procedures as below:

==== 1. Download the image package and burn it into the SD card ====

Download the image package [http://support.omekinteractive.com/index.php?/TI/managedownloads/Download/View/32/11/installation Beckon-Image-2.4.19872.tar.gz] as mentioned above onto your Linux PC. Then extract it by entering

host$ '''tar -xvzf ''<ImageFileName>'''''

Run the following command to make sure you have bash installed.

host$ '''sudo apt-get install bash'''

Insert your SD card using a card reader/writer. Run the following command:

host$ '''sudo bash mkcard.sh /dev/''<sdX>'' beagle-omek'''

''Note: This action will wipe out and rewrite the SD card so make sure the files in it are backed up. The name of the SD card can be viewed in Disk Utility. If you mistakenly use the main OS device name this script can erase your entire OS.''

==== 2. Run the sample application ====

Plug the sensor into the BeagleBoard-xM USB port. Ensure the mouse and keyboard are connected to the BeagleBoard-xM USB port. Connect the BeagleBoard-xM to the monitor with an HDMI cable. Connect the BeagleBoard-xM power supply and wait for the boot process to reach the login prompt, login as user root (no password is required). Now it's ready to run the sample applications on the BeagleBoard-xM.

''Note: Details about running the samples can be found in the developer's guide from page 9 to 11. The Kinect will react properly only if the player is within an appropriate distance (about 1m - 5m). ''

Note: The following instruction is about how to set up the environment for developing. If you don't want to do the development, you can just skip that.

==== 3. Setting up your Linux development PC ====

Download [http://support.omekinteractive.com/index.php?/TI/managedownloads/Download/View/32/11/installation Beckon-SDK-2.4.19872.tar.gz] and extract it onto your host PC (this is the actual SDK which contains headers, libraries, documentation, makefiles, etc...) The SDK provides the tools to develop a motion-tracking and gesture-based application that can run on the BeagleBoard-xM. After developing the application, cross-compile it onto the Linux PC and then copy the image onto the BeagleBoard-xM via external USB storage.

1) Download the Linux ARM cross toolchain:

For 32-bit Ubuntu you will want to download this file: http://www.angstrom-distribution.org/toolchains/angstrom-2011.03-i686-linux-armv7a-linux-gnueabi-toolchain-qte-4.6.3.tar.bz2

For 64-bit Ubuntu you will want to download this file: http://www.angstrom-distribution.org/toolchains/angstrom-2011.03-x86_64-linux-armv7a-linux-gnueabi-toolchain-qte-4.6.3.tar.bz2

Extract the downloaded archive into your system root directory:

host$ sudo tar -xvjf ''<ToolchainFileName>'' -C /

''Note: If you extract the archive into a different directory, you should adjust the following instructions as well as the samples' makefiles accordingly.''

2) Install the Qt embedded SDK for Angstrom/BeagleBoard:

Now that you have your cross compiler installed, you can compile Qt with it. First thing to do is to install zlib library:

host$ sudo apt-get install zlib1g-dev

Then download the Open Source LGPL version of Qt libraries 4.6.2 for Embedded Linux [http://get.qt.nokia.com/qt/source/qt-everywhere-opensource-src-4.6.2.tar.gz here].

''Note: Newest version of Qt libraries can be found [http://qt-project.org/downloads/ here]. We didn't test it since the 4.6.2 version works fine.''

Extract the file you just downloaded:

host$ tar -xvzf ''<DownloadFileName>''

You need to create a new make.conf. Run the following line to make a new mkspecs directory for the BeagleBoard Processor.

host$ cp -R ''<DownloadDirectory>''/mkspecs/qws/linux-arm-g++/ ''<DownloadDirectory>''/mkspecs/qws/linux-DM3730-g++/

Edit the qmake.conf file found in ''<DownloadDirectory>''/mkspecs/qws/linux-DM3730-g++/ and overwrite it with the following lines.

<pre>
#
# qmake configuration for building with arm-linux-g++
#

include(../../common/g++.conf)
include(../../common/linux.conf)
include(../../common/qws.conf)

# modifications to g++.conf
#Toolchain

#Compiler Flags to take advantage of the ARM architecture
QMAKE_CFLAGS_RELEASE = -O3 -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp
QMAKE_CXXFLAGS_RELEASE = -O3 -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp

QMAKE_CC = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/gcc
QMAKE_CXX = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/g++
QMAKE_LINK = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/g++
QMAKE_LINK_SHLIB = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/g++

# modifications to linux.conf
QMAKE_AR = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/ar cqs
QMAKE_OBJCOPY = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/objcopy
QMAKE_STRIP = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/strip

load(qt_config)
</pre>

Now run the configure command (see this [http://processors.wiki.ti.com/index.php/Building_Qt website] for more details if needed):

host$ cd ''<DownloadDirectory>''

For 32-bit Ubuntu:

host$ ./configure -opensource -confirm-license -prefix /opt/qt-arm -no-qt3support -embedded arm -little-endian -xplatform qws/linux-DM3730-g++ -qtlibinfix E

For 64-bit Ubuntu:

host$ ./configure -opensource -confirm-license -prefix /opt/qt-arm -no-qt3support -embedded arm -little-endian -platform qws/linux-x86_64-g++ -xplatform qws/linux-DM3730-g++ -qtlibinfix E

Once this is complete you can run make and make install (make may take some hours):

host$ make
host$ sudo make install

3) Install and set up Qt Creator:

Go to http://qt-project.org/downloads to download Qt. Get the latest version of Qt for Linux/X11; be sure to get the appropriate 32bit or 64bit version. Once downloaded go to the download directory and execute the following using your download file name:

host$ chmod u+x ''<QtCreator.bin>''
host$ ./''<QtCreator.bin>''

''Update:''The free version Qt Creator can not be used in this project since it doesn't have cross-compile option with it.

After Qt Creator is successfully installed, start Qt Creator. Go to: Tools > Options > Build & Run > Tool Chains, select Add -> GCC and insert the full compiler path below:

/usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/g++

Then go to: Tools > Options > Build & Run > Qt Versions, select Add and provide the following full path to qmake

/opt/qt-arm/bin/qmake

Press Apply and OK.

==== 4. Setting up the BeagleBoard-xM ====

All of the Qt files that you need to move to the BeagleBoard can be found in the /opt/qt-arm/lib directory on your Linux Build System. Copy all the files out of your build system's /opt/qt-arm/lib directory and put those into the BeagleBoard-xM's /opt/qt-arm/lib directory. You can get the files to the Beagleboard by either networking, using a usb drive or plug the SD card into your Linux Build System.

== User Instructions ==

===Building and running samples===

To build QtTracking Sample:

1. Start Qt Creator.

2. Go to: File > Open File or Project, select the QtTracking-SDK.pro project (from Beckon-SDK-{version}/samples/QtTracking) and click Open. Select Embedded Linux instead of Desktop.

3. Click Finish.

4. Go to Projects tab (on the left), In Qt version select Qt [4.x.x (qt-arm)]/.

5. Run Build -> Build Project command.

The result executable can be found in the Beckon-SDK-{version}/bin directory.

To run the QtTracking Sample:

1. Mount or copy the bin directory to the BeagleBoard.

''Note: Run the reset.sh script inside the "bin" folder of the SDK before each sample run, to reset the DSP.''

Run the following:

beagle$ ./QtTracking-SDK –qws

''Note: Developer's guide has more instructions on running the sample''

===The Snake Game===

The Snake Game can be downloaded from https://github.com/Astroricks/Snake-Game-with-Kinect-on-BeagleBoard-xM. To play with it you should copy the folder to the root directory of SD card. Since what we did is combining the Snake Game source code into the Tracking Sample, running this application would be the same way as running the samples.

We suggest playing with the following command:

beagle$ cd Tracking_Sanke/bin/
beagle$ ./QtTracking-SDK –qws -upper

When the application is running, we suggest pressing the "setting" button first to enable the wall-cross mode, which could make it not so easily "game over". To start the game, you need to press Up Arrow(or Arrows of other directions) on the keyboard. And the player would get a better playing experience if he/she stands in front of the Kinect with a distance of about 1.5m - 2m. The player should control the snake with his '''right hand''' moving up and down, left and right.

== Highlights ==

Our project is about how to use Microsoft Kinect Sensor to play snake game by the motion of you right hand(You can modify the codes to change to any part of your body if you would like to). We set a score section to record the highest score. Anybody who want to break our record are welcome(Currently the record is holding by Xinyu Cheng at 260). We've created a play demo and uploaded it to YouTube:

=== Play snake game with Kinect sensor on BeagleboardxM ===
{{#ev:youtube|uBW6LkVUi9I}}

== Theory of Operation ==

=== The Main Idea ===
We are using the kinect as the sensor of our project. The provided algorithm of the kinect make it possible for us to get the coordinate of many joints of the body. In this case, we can judge the position and the motion of our hands or any other joints. Then, we can use the direction we get from the previous judgement to control the Greedy Snake. Our project is running with the idea.

=== The Technics Used ===
Technically, we can use QT to design our program and then cross-complie our project to the beagle-board. The Greedy Snake is an open-source QT game, and the tracking of the joint can be accomplished from modifying the Omek SDK. We have to modify both of their codes to connect the two parts together.

=== The Control Strategy ===
Judging gestures simply from the changing of coordinate is hard and may lead to mistakes commonly. To improve the playing experience, we combined two methods to guess which control direction the player wants to make.

1. Compare the current coordinate with the last time. When the date is refreshed, we can compare the current coordinate of player's right-hand withe the last time value. If the difference between the coordinates of x or y is larger than the threshold, it is reasonable to think that the player may want the snake to make a move in this direction.

2. See where the hand locates. After making a upward movement, it has a high possibility that the y coordinate locates in the up area. Similar situation appears in other movement directions. So by checking the current value of the x and y coordinates we can know which direction the player want to make move.

Only when the same direction is implied by both methods, we move the snake in this direction. It seems that this control strategy works pretty well.

== Work Breakdown ==

=== Yue Zhang ===
* Researched how to Burn the correct Image to the Beagle Board.
* Configure the Beagle Board to control the kinect.
* Implemented the motion based algorithm which makes the application runs more smoothly.
* Programmed for the part of motion algorithm.
=== Xinyu Cheng ===
* Researched how to configure the QT programming environment.
* Accomplished the cross-compiling on QT.
* Programming for the connection between the Snake Game and the Kinect SDK.
* Designed and Implemented the coordinate based algorithm.
=== Xia Li ===
* Researched how to run the provided SDK demo.
* Speed up for the demo.
* Designed the motion based algorithm.
* Programmed to improved the accuracy and speed of the game.

== Future Work ==

Now, our game can work pretty good and smoothly. The future work for the project will mainly about the following aspects:
* Improve the user interface, make the game looks more pretty.
* Improve the game rules, to make it more interesting.
* Improve our algorithm for the direction judgement, to make the game runs more smoothly.
* Display the motion of our hand on the window, to make the user more clear about the motion of their hands.

== Conclusions ==

Conculsionly, our project works pretty good. Our Greedy Snake game runs very good and brings a lot of fun for us.

During the develop process, we met lots of difficulties, we tried to solve them one by one. The first problem we met is how to build the connection between the kinect and the game. We tried very hard to debug our program step by step, then finally found the bug and fixed it.

We can still do something more to improve our project. Like we have talked about in the "Future Work" part, we can try to improve the GUI of our game to make it looks more pretty, and improve our display inforamtion and the algorithm for the game to make it easier for users to play. So, to make the game perfect, there is still a long way to go.

{{YoderFoot}}

ECE497 Project RoverGUI

2013-05-18T16:19:52Z

Yoder: Removed grade. Moved to Fall2012

[[Category:ECE497Fall2012 |Project]]
{{YoderHead}}

Team member: [[user:chris.good|Chris Good]]

== Executive Summary ==
This project is to create a GUI that could be used to control the rover project found here:[[ECE497_Project_Rover]] The GUI will have two interfaces. The more simple one can control forward, backwards, and turning. The other will be GUI based on the Google Maps API so that users can click waypoints for the rover to travel.

The curent code will allow the user to place into a file either simple commands or a list of coordinates from the Google Maps API.

Although in itself this project would likely not be of much use, it will give certain projects a very useful and easy to integrate user interface.

== Installation Instructions ==
First, ensure node.js is installed by running:

beagle$ '''opkg install nodejs'''

Next, the GUI can be downloaded from [[https://github.com/goodca/roverGUI.git https://github.com/goodca/roverGUI.git]]

No compiling is needed so the GUI is now ready to be used.

== User Instructions ==
Move to the top level of the directory GUI directory. To run the GUI server, run:

beagle$ '''node GUI.js'''

Then, from any networked browser point to:

beagle$ '''beagle:8081'''

where ''beagle'' is the IP of the BeagleBone.
The browser will now be pointed to the home screen of the GUI. Either the simple direction GUI or the Google Maps GUI can now be selected by clicking the text of the option you would like to select.

[[File:RoverGUIHome.PNG]]

Selecting the simple control option will send you to the simple control GUI.

[[File:RoverGUISimple.PNG]]

Clicking on a button will cause create a file in the top directory of the GUI directory called inst.txt that will contain only the text from the button most recently clicked. In this way, the program to be controlled can watch this file and carry out the instruction currently in the file. With some easy modification to the source code more buttons can be created that will add any additional functionality.

If instead the maps GUI was clicked the following will be displayed

[[File:RoverGUIMapsStart.PNG]]

From here you can navigate the map as is likely familiar with Google Maps. However, any time the map registers a single left click a marker will be placed. Every additional marker after the first will place a second marker with a line from the preceding marker. This can continue as long as many times as the user would like markers placed.

The following is an example of a marker placed on Rose-Hulman's campus, New York City, Chicago, Louisville, and then back to Rose-Hulman.
[[File:RoverGUIMaps.PNG]]

Once finished, the user can click the "done" button near the top of the page. At this point, the inst.txt file in the GUI directory will be populated with the coordinates of each marker in the order they were clicked. The following is the resulting file from the example map.

'''(39.4824644923698, -87.32401371002197)
'''(41.88592102814744, -87.626953125)
'''(41.50857729743935, -81.683349609375)
'''(38.27268853598097, -85.75927734375)
'''(39.48246138709902, -87.32401169836521)'''

== Highlights ==
This GUI is designed to be extremely easy to interface to other programs. If the other program can be created to read a text file of either instructions or coordinates it can likely be made to use this GUI.

The Google Maps GUI makes it very simple to create a list of GPS coordinates. This would make creating tests much simpler for any testing that makes use of GPS coordinates.

== Theory of Operation ==

The server on the BeagleBone is running using node.js. With between the BeagleBone and the browser is handled by node.js and socket.io. The GUI will then use either basic socket.io buttons or the Google Maps API to send instructions to the BeagleBone. The instructions are then saved to a file on the BeagleBone.

More details would help. How do you interact with Google Maps? What messages are being sent back and forth between the server and the browser, etc.

== Work Breakdown ==

All work was done by Chris Good

== Future Work ==

Extra buttons can be easily added to the simple GUI through modifying the source code. These buttons could carry any actions the user intends to have.

Currently the Maps GUI only reports latitude and longitude coordinates. While this is fine for ground based objects such as the Rover this project was designed to work with, it could be expanded to allow a height coordinate in order to accommodate aerial objects. Further parameters such as travel velocity or a time to stay at a coordinate could also be added.

== Conclusions ==
This project gives an easy to integrate GUI solution for devices that make use of simple direction commands or gps coordinates for the purpose of way-points.

{{YoderFoot}}

ECE497 Project Rover

2013-05-18T16:19:18Z

Yoder: Removed grade. Moved to Fall2012

[[Category:ECE497Fall2012 |Project]]
{{YoderHead}}

Team members: [[user:Hansenrl|Ross Hansen]], [[user:jessebrannon|Jesse Brannon]], [[User:jungeml|Michael Junge]]

== Executive Summary ==

This project is a BeagleBone implementation of a ground-based rover platform. Through a BeagleBone mounted on an RC car, the car can be directed to turn to a specified compass heading or move forward. A user is able to control the car with predefined movement code or in real-time over WiFi. The BeagleBone can also send back helpful information to the user over Wifi, such as GPS location and compass heading. Although not complete, functionality to direct the rover along a path by defining waypoints is currently in development.

This work provides highly useful code even for applications outside of this specific rover project - digital compass and GPS sensor interfacing, Python-based networking, and RC car motor control code is all written and easily extendable into other applications. Additionally, the work performed for this project in the area of RC car reverse engineering and BeagleBone USB Wi-Fi can serve as useful community knowledge for other projects.

== Installation Instructions ==

We bought an RC car from [http://www.toysrus.com/product/index.jsp?productId=12925248 Toys 'R Us] and modified it to become an intelligent platform by utilizing a BeagleBone. To successfully recreate our work, certain skills will be helpful: dremel-based hardware modification, soldering, experience with Beagle Bone or an equivalent embedded processor bases system, familiarity with the Python and C programming languages, and basic circuit knowledge such as power regulation from batteries.

=== Modifying RC Truck/Car ===
[[File:ECE497 Rover truck hardware.JPG|thumb|Figure 1 - Electronics housing]]
[[File:ECE497 Rover circuitBoard.JPG|thumb|Figure 2 - Motor control PCB]]
[[File:ECE497 Rover circuitBoard2.JPG|thumb|Figure 3 - Motor control pins]]

As shown in Figure 1, we removed the aesthetic cover form the truck. We also cut out most of the plastic with a Dremel tool. We did this to expose the circuity below. Cutting out most of the plastic is necessary unless you are skilled enough to drill only a small hole to feed the wires through and can replace the circuit board back into place without viewing it. Figure 1 also shows, four screw slots. In order to obtain access to the circuity, you must remove the screws from their sockets. Now turn the truck so that it's undercarriage is facing up, remove the housing unit of the battery. The battery unit should be loose and thus be removed since you already removed the four place holder screws. Be careful though to not pullout or detach any wires from the their respected places as you are pulling out the circuit board. Figure 2 shows the circuit board removed from it's housing with the wires exposed. The red and black wires you see are respectively power and ground, the same for all electrical work.

Figure 3 is focused on the specific connections that we soldered to the board. We choose the top left corner (where three of the connections are) because when we reverse engineered the board, this area is where the wireless signals are received and sent to the motor controllers. The fourth wire was supposed to be the pin on the right but as you can see by the picture, the circuit pad is burned off. We just followed the hard trace and soldered at the next available node. After testing, this improvised step seemed suitable for our needs. The same four pins are labeled on the circuit board as F,W,L,R. Originally, we thought these meant forward, backward, left and right. However the RC Truck is designed with tank steering so in order to go forward it theoretically should require two separate signals. We tested this theory and found out that it did in fact require two signals, thus the F,W,L,R labels are incorrect. The pins attach to relays on each motor, and correspond to "right forward", "right backward", "left forward", and "left backward", and are digital control signals. Therefore, in order to turn left you would drive the "right backward" and "left forward" pins high. Fortunately, motor conflicts are not destructive and exact pin mappings can be determined by experimentation - if you mistakenly drive the "right forward" and "right backward" pins high, for instance, the relay will click and the motors will not move, without any damage to the motors or electronics.

If you want to reverse engineer this circuit board for yourself instead of just following this guide, you will need a separate 5V dc power supply as well as the 9V battery that was included, a 5V wall adapter with stripped wires will be suffient for the extra power supply. Then you should look for the wireless adapter board. Most RC electronics will have a separate wireless circuit board. Ours happened to be already physically attached to the motor controllers. Find the output signals from the wireless adapter and test which signals control which motors and direction of motors. To test this just attach the 5V to the pin on the circuit board while the truck battery is installed and switched on. Also you will need to find a ground wire to attach for common ground. We just soldered directly to the terminal on the installed battery for our ground.

=== BeagleBone ===
[[File:ECE497 Rover Power Circuit.jpg|thumb|Figure 4 - Power Circuit]]
[[File:ECE497 Rover 5v regulator.JPG|thumb|Figure 5 - Regulator Circuit]]
After several problems with the WiFi on the BeagleBone not working as expected, we decided to overwrite our Angstrom Beagle Image with Ubuntu. To install Ubuntu, we simply followed [http://www.instructables.com/id/BeagleBone-Ubuntu-OS-LXDE-GUI/ this Instructable] up to and including Step 6. There is also good information on the [http://elinux.org/BeagleBoardUbuntu BeagleBoardUbuntu] page on elinux.org.

However, if you want to pursue the Angstrom route then I would suggest reading Dr. Yoder's [http://elinux.org/EBC_Exercise_02_Out-of-the-Box,_Bone Out of The Box, Bone]. ''Note: If you want WiFi to work properly, install the A5 image not the A6 image.''

Whether you use the Angstrom image or Ubuntu is up to you. However, you will still need to wire the BeagleBone up so that it runs off of battery power. We bought a 7.4 Vdc 10400 mAh [http://www.all-battery.com/li-ion1865074v10400mahrechargeablebatterymodulewithpcb-31577.aspx battery]. Since the BeagleBone runs off of 5V with a possible peak current of 1.5 amps we needed a 5V regulator that can supply that power [http://www.ti.com/product/lm2576hv voltage regulator]. To be safe and avoid short-circuiting the BeagleBone, it is advisable to buy a [http://www.digikey.com/scripts/DkSearch/dksus.dll?WT.z_header=search_go&lang=en&keywords=CP3-1000-ND&x=0&y=0&cur=USD barrel connector] for proper power connection. This barrel connector replaces the need to solder wires to the hardware of the BeagleBone, thus allowing for us to safely supply power the way the BeagleBone was designed. As seen in Figure 4, the barrel connector, battery and voltage regulator with heat sink can be seen. Figure 5 is our Regulator circuit. It shows how to connect the regulator to the rest of the BeagleBone hardware.

''Note: We specifically used a BeagleBone for it's smaller size and less cost due to less capabilities. However, you could use any board that has an Omap processor, such as the Beagle XM Board.''

===WiFi Network===
Connecting to WiFi is an important part of our project. We intended this project to receive data from a user on a mobile laptop. We decided to use WiFi to avoid following the RC truck around a field with the laptop in our hands. WiFi helps the user stay in the same place while the RC truck moves around the field. We ordered an [http://www.adafruit.com/products/814 Adafruit WiFi adapter] that Adafruit specifically sponsors for the BeagleBone. They also have an install tutorial. After several days of researching WiFi capabilities for the BeagleBone, we continually ran into many difficulties. One of the many difficulties is with 'opkg upgrade' that Adafruit says to run. DO NOT RUN 'opkg upgrade'. Depending on what software image you are running, you will receive an error that for some reason cannot be resolved. There are many reported cases on [http://forums.adafruit.com/viewforum.php?f=49&sid=1a1b1e0fba73bb5659a3446079a5f423 Adafruit's help forums]. There are also several more reported cases for the BeagleBone group on google groups. After researching and WiFi experimentation we discovered that the Adafruit WiFi adapter works well on the A6 version of the BeagleBone hardware while running A5 version of Angstrom. This is the only valid combination we could find. The A5 hardware shows and detects the adapter, but for some reason the adapter does not connect to a wireless router. When the same SD card is plugged into an A6 hardware, it connects fine without issue to a router. We also noticed that the A6 software image does not even recognize the BeagleBone following the same procedure as for the A5 software.

Because of the difficulties, we decided to not use the Angstrom images supported by Beagle. We instead installed Ubuntu Operating system on our A6 hardware. With Ubuntu installed it was as easy as plug and play. All we did after installing Ubuntu was to physically plug in the adapter and it was recognized immediately. However, if you want to stay with Angstrom I would suggest following the directions in [http://elinux.org/ECE497_Beagle_Bone_WiFi ECE497 Beagle Bone WiFi].

=== Software ===

The code for the platform can be found on the [https://github.com/hansenrl/BeagleRover BeagleRover Github Page] and [git://github.com/hansenrl/BeagleRover.git Github Repository].

A Makefile is provided, and the code can be compiled with the command "make" in the root directory of the project; this will build a main binary ''movement'' and shared libraries for movement control over WiFi.

See the README for detailed instructions on installation and documentation of the code structure.

== Required Parts List ==
1 x [http://www.toysrus.com/product/index.jsp?productId=12925248 RC Truck]

1 x [http://beagleboard.org/buy BeagleBoard] (could be Bone/XM/Board)

1 x [http://www.all-battery.com/li-ion1865074v10400mahrechargeablebatterymodulewithpcb-31577.aspx Battery]

1 x [http://www.ti.com/product/lm2576hv Voltage Regulator]

1 x [http://www.digikey.com/scripts/DkSearch/dksus.dll?WT.z_header=search_go&lang=en&keywords=CP3-1000-ND&x=0&y=0&cur=USD Barrel Connector]

1 x [http://www.adafruit.com/products/814 Adafruit WiFi adapter]

1 x [https://www.sparkfun.com/products/11466 GPS]

1 x [https://www.sparkfun.com/products/7915 Compass]

1 x BreadBoard

Various Wires

Soldering Tools

== User Instructions ==
The rover is designed for two different operating modes.

# Stand-alone control and navigation
# Remote operation over Wi-Fi via Python

The README file on the software [https://github.com/hansenrl/BeagleRover Github Page] includes details about running the software for each of these modes. For stand-alone operation, the compiled binary ''movement'' can be executed to run commands such as moving forward or turning to a specific heading. For remote operation, Python scripts are provided to setup a server/client interface to communicate with the BeagleBone. When communicating with the Bone over Wi-Fi, the Python script presents the user with options of what to send to the BeagleBone.

Selection:
1: FWD
2: BCK
3: TURN
4: COMPASS QUERY
5: GPS QUERY
9: EXIT

The user then inputs the selection number, and an option if necessary. For instance, the option for sending a "FWD" command is the duration in microseconds, while the option for a "TURN" command is the heading relative to magnetic north. FWD, TURN, COMPASS QUERY, and GPS QUERY are all implemented and functional, but BCK is currently unimplmented; the code is simple and implementation would be trivial, but for the end application of this software (emulating UAV movements) it was unnecessary.

Upon sending the command, the BeagleBone will return feedback to the user over Wi-Fi. In the case of a movement command it will return that the command was executed successfully, and if a sensor was queried it will return the result. The Python script will then prompt the user for another command to send.

== Highlights ==
{{#ev:youtube|g_-srPShIiU}}

In the video we demonstrate how to set up the wireless server/client communication and the functionality present over the network interface, including sensor queries and movement commands. Although these movements are accomplished over Wi-Fi, they can also be programmed for stand-alone operation. The jerky turning and vigorous stopping that the car displays in the video is due to the high traction of the tires on the track surface - reducing the traction on the tires would eliminate this.

== Theory of Operation ==

=== Hardware Interfaces ===
[[File:ECE497 Rover gpio Pins.jpg|thumb|Figure 6 - GPIO Pin Connections]]
[[File:Bone P9 pinout.jpg|thumb|Figure 7 - P9 Header Layout]]
[[File:ECE497 Rover compass.jpg|thumb|Figure 8 - Compass and GPS Pin layout]]
[[File:ECE497 Rover gpsCompass mount.jpg|thumb| Figure 9 - Compass, GPS, and WiFi mount]]

The BeagleBone is connected to the RC car via 4 GPIO pins and a ground wire. The four GPIO pins control left forward, left reverse, right forward, and right reverse on the tank-style drive base. Tank-style means that each side is controlled independently, as opposed to a standard steering where the user controls whether the car as a whole is moving forward or reverse and turns are accomplished by rotating the front axle. Figure 6 shows how the GPIO pins on BeagleBone are connected to the motor control PCB. As seen in Figure 4 the motor control wires are white. The GPIO pins are the two orange and two yellow wires labeled in the figure.

Seems like you need a PWM control so the motors can run slower.

The Motor Control pin layout is listed below. These are defined in movement.c, and can be redefined easily to match a different pin configuration. These pins are connected to relays on the RC car, so the motors are either on or off.
Motor Control BeagleBone Pin

Right Forward 40 - P8 header (software sysfs GPIO 77)
Right Reverse 44 - P8 header (software sysfs GPIO 73)
Left Forward 42 - P8 header (software sysfs GPIO 75)
Left Reverse 46 - P8 header (software sysfs GPIO 71)

WiFi is achieved with Adafruit's [http://www.adafruit.com/products/814 USB WiFi Module]. The USB WiFi Module is connected to the only usb port on the BeagleBone.

Figure 7 is the BeagleBone P9 Header layout and provides a good reference in knowing which pins in the header connect to pins on the BeagleBone. Figure 8 shows how the pins for the gps and compass are connected to the P9 header. Figure 9 shows where the Compass, GPS and WiFi module are mounted. We had to mount them outside of the box because placing them inside of the wooden box attenuated the signals excessively.

The [https://www.sparkfun.com/products/11466 GPS] is connected to the BeagleBone over UART serial. The GPS pin layout is as follows:
GPS BeagleBone Pin

1 - TX 24 - P9 header
2 - RX 26 - P9 header
3 - GND 1 or 2 - P9 header
4 - 3.3 V 3 or 4 - P9 header
5 - NC
6 - NC

Over UART, the GPS sends back 6 strings in NMEA format every second. Each of these 6 strings includes some or all of the following data: Latitude, Longitude, if the GPS has a fix, UTC time, and some other data that we don't need. For more information, read the [http://dlnmh9ip6v2uc.cloudfront.net/datasheets/Sensors/GPS/D2523T-6_SPEC_20120220.pdf GPS' datasheet]. We chose to parse the string that starts with "$GPGLL" because it included all of the information we need listed previously.

The format for the $GPGLL string is:
$GPGLL,Latitude,N/S,Longitude,E/W,UTC time,Fix Status,Mode Indicator,Checksum

This is what the $GPGLL string looks like when the GPS does not have a fix.
$GPGLL,,,,,231429.00,V,N*45
We know the GPS doesn't have a fix, because of the 'V.' The second to last comma-delimited item will be 'V' when there is no fix and 'A' when there is a fix. Also, the Latitude and Longitude fields are left blank when there is no fix, as shown.

The [https://www.sparkfun.com/products/7915 compass] is connected to the BeagleBone via I2C. The Compass pin layout is as follows:
Compass BeagleBone Pin

1 - GND 1 or 2 - P9 Header
2 - 3.3 V 3 or 4 - P9 Header
3 - I2C SDA 20 - P9 Header
4 - I2C SCL 19 - P9 Header

The compass simply returns the current heading at a default rate of 20 Hz.

=== Software ===

All hardware interfacing is accomplished in C, using the standard interfaces for each protocol. Motor control is done via GPIO, the compass is I2C, and the GPS is UART. Compass interfacing is provided in a compass library ''Compass/compass.c'', GPS interfacing is provided in a GPS library ''GPSLibs/gps.c'', and the motor control is provided in ''movement.c''. Waypoint storage and helper functions are provided in a library in ''Waypoints/waypoint.c''.

For stand-alone operation, ''movement.c'' is compiled with the necessary libraries as a stand-alone binary.

For network operation, the Python scripts utilize compiled libraries in sharedLibs. Currently, due to the structure of how the sensors are interfaced in the movement library, all interfacing is accomplished through a library ''movementLib.so'', which provides wrapper functions to the GPS and Compass. In the future, this functionality should be better divided out into each individual sub-library. This interfacing between Python and C is done with Python [http://docs.python.org/2/library/ctypes.html CTypes]. The BeagleBone and base station communicate over Wi-Fi using TCP sockets via the Python [http://docs.python.org/2/library/socket.html Socket] and [http://docs.python.org/2/library/socketserver.html SocketServer] modules. All of these Python modules, ctypes, socket, and SocketServer, are standard in Python 2.7.

== Work Breakdown ==

A summary of the major development areas and the primary contributor(s) to each subsystem:

* RC car hardware interfacing and mounting: ''Michael Junge''
* Power subsystem development: ''Michael Junge''
* Wireless communication hardware: ''Michael Junge'', ''Jesse Brannon''
* GPS and Compass sensor interfacing: ''Jesse Brannon''
* Movement and navigation software development: ''Jesse Brannon'', ''Ross Hansen''
* Network communication software development: ''Ross Hansen''

Tasks completed and in development by each team member:

'''Michael Junge'''
* Constructed hardware interfaces to compass sensor and drive base electronics
* Investigated WiFi issues on Angstrom - determined that the Angstrom A5 image on BeagleBone A6 hardware is a known working configuration ''**still under invesgitation, won't be fully completed due to hardware/software issues between Angstrom and Beagle''
* Soldered and interfaced battery subsystem to power BeagleBone

'''Jesse Brannon'''
* Decided and installed an Ubuntu image instead of Anstrom specifically for the WiFi functionally
* Researched and purchased compass and GPS sensors
* Wrote libraries to interface to compass and GPS sensor
* Co-developed movement and navigation software

'''Ross Hansen'''
* Co-developed movement and navigation software
* Developed software for network communication

'''Tasks Remaining'''

Although full rover functionality for movement and sensor data retrieval was completed, two additional features were currently in development at the end of the original timeframe of this project.

1) Code to manage waypoints and drive the motors based off of waypoint inputs

2) Improve GPS library to allow for update rate configuration

These two features were not necessary for this project, but are useful for a sister project in development by the same team; so development will continue on these two tasks. The code in the BeagleRover repository will be updated with final versions of the code as it is completed.

== Future Work ==

This project has the possibility to branch into several interesting areas.
* The BeagleBone platform has the processing power for various interesting sensory systems, such as computer vision. The RC car interface and networking platform allows for a variety of interesting applications of sensor systems, where driving decisions are made based off of sensor inputs or sensor data is relayed remotely back to a powerful processing node.

* A GUI is being developed that could be used to send commands to control the rover. Work on it can be seen here: [[ECE497_Project_RoverGUI]]

* This project is a two-dimensional navigation system for a ground-based rover, but could be extended for use on aerial vehicles. Additional requirements for this would include some sort of altimeter sensor interface, modification of control outputs to accommodate aerial control surfaces, and an addition of a third dimension to location and navigation code.

== Conclusions ==

BeagleRover is a functioning implementation of a rover intelligence platform for the BeagleBone. When mounted on an RC car, the BeagleBone can direct the car motors to move around and it can relay GPS and compass data across a Wi-Fi network.

This project was highly interesting and enjoyable to work on. It incorporated a wide range of skills fundamental to embedded systems - hardware, sensor interfacing via multiple protocols, and both high and low-level software development. Although a complete project in its current status, even more exciting is the possibility for extension in the future; the basic system of network functionality, location and heading sensor data, and mobility provide an interesting platform for lots of different embedded work. Combined with the versatility of Linux running on the BeagleBone, this project provides an interesting application of the BeagleBone's potential and a flexible platform for future development.

{{YoderFoot}}

ECE497 Project Remote Web Cam Viewer

2013-05-18T16:18:41Z

Yoder: Removed grade. Moved to Fall2012

[[Category:ECE497Fall2012 |Project]]
{{YoderHead}}

Team members: [[user:Draneaw|Alexander W. Drane]], [[user:Lobdeljt|John Lobdell]]

== Executive Summary ==
The goal of this project is to create a simple webcam based security system that allows a user to remotely view the device's web cam by navigating to a webpage. Then using buttons the user can change what camera they are viewing.

Currently we have the ability to select a camera and view the stream in a remote webpage. This view uses the browser's VLC Plugin. We have tested this with 4 webcams on the xM board.

Operating with four webcams hooked to the board causes many failures of the system to stream back the video information. We determined that this was due to the physical cameras and the overhead of the devices by testing the system with only two we cams where the issues experienced regularly with the four camera setup greatly reduced in frequency.

Investigation of how to accomplish this task took up the bulk of our time and effort largely due to the infancy of HTML5 Related standards(sockets.io and MediaStream). In the end we decided to utilize the vlc plugin when the HTML5 proved unfeasible at its current level of development. Implementing the four cameras did seem to cause some device issues that caused the webpage to not sync with the incoming feed, but this appears to be hardware related only and not from the implementation (a further explanation is later on).

== Installation Instructions ==

Extra Hardware Required:
*Webcam 1+ (or Playstation Eye's) Max 4 without other supplementary hardware. Best performing build currently is 2 web cams on the board. 4 makes the XM Slow down too much.

*Connected to the internet.

First Download the git Repository, it is located here:[https://github.com/jtlobdell/bbWebcamFeed.git WebcamFeed]

xm$ '''mkdir WebcamFeed'''
xm$ '''git clone git://github.com/jtlobdell/bbWebcamFeed.git WebcamFeed'''
xm$ '''cd WebcamFeed'''

Install Node.js
xm$ '''opkg update'''
xm$ '''opkg install nodejs'''

Verify gstreamer is available and up to date

xm$ '''opkg update'''
xm$ '''opkg install gstreamer'''

One last thing must be done on the user computer. VLC Media Player Plugin must be available in your browser of choice. This can be done by downloading the software here: [[http://www.videolan.org/vlc/index.html]] and making sure during installation to install the browser plugin. Many modern browsers will guide you through this if you run into a page that requires a missing plugin.

Now for reference type the following to get the xM's IP address. It is needed quite soon

xm$ '''ifconfig'''

== User Instructions ==
Move to the source directory
<source lang="text">
xm$ cd ./WebcamFeeds/
</source>

The current code does not automatically direct the VLC plugin to play from the correct IP address; it relies instead on passing a hard-coded IP address to the client in the WebcamFeed.html file. Modify the following code in the file to use your xM's IP address:
<source lang="text">
<embed
type="application/x-vlc-plugin"
name="videoplayer"
autoplay="yes" loop="no" hidden="no"
width="320" height="240"
target="tcp://[YOUR_BEAGLE_IP]:8080" />
</source>

Once the installation is done, the program is ready. Run it using:
<source lang="text">
xm$ node WebcamFeed.js
</source>
Now navigate on the user computer using a web browser to your computers IP Address. Once there click on the link to the video feed page. The program will start and video should play.

NOTE: When changing video feeds the XM will randomly not load and play the feed. This we believe is due to the physical limitations of the hardware. We tested this by attaching 4 webcams to the board and found that the failure rate went up drastically. When the extra 2 webcams were removed the failure rate returned to where it was before. Since the program only ever calls one feed at a time(it changes which device it targets) this has to be a memory or hardware related issue and not due to the software.

At the top of the screen is a text box which can be entered the desired video device. Each camera is added sequentially starting at 0. Below the Set Cam button are four buttons for convenience. These function identically as entering the number's 0 though 3 into the text box and clicking Set Cam for each number.

== Highlights ==

A single video is captured from a web cam and streamed to a web page. The video capture device can be selected from the same page.

This program implements node.js and GStreamer working together to accomplish the video output and control over which video device to be viewed.

The software allows for as many video capture devices (webcams) as can be connected to the device. In the case of the Beagle Board xM, up to four cameras can be used. We only access one webcam at any given time and so the only increasing overhead on the system is that which is associated with the individual USB webcam's.

[http://youtu.be/kPK35JGzazY Here is a YouTube video demo of the four camera operation]. A picture of the test setup is shown below:

[[File:BbWebFeed_demo_setup.jpg|400px]]

This video starts out very slow and illustrates some of the hardware related issues that were encountered. While the most effective implementation currently is the two camera version we wished to show that four camera feeds could be accessed on the xM.

== Theory of Operation ==

The project uses [http://gstreamer.freedesktop.org/ GStreamer] to capture video from a webcam, convert it to video/ogg format, and stream it through Transmission Control Protocol (TCP). A diagram of the GStreamer pipeline is shown below.

[[File:BbWebcamFeed_Gstreamer_pipeline.png|400px|Web Cam Feed - GStreamer Pipeline]]

The client system connects to a node.js server running on the xM. The server embeds the video stream into the web page and also contains controls for selecting a webcam for the stream.

When the server begins running the node.js script, it launches the GStreamer pipeline discussed above. When the client connects, they receive a web page containing controls for the video source and the embedded video that gets played using the [http://www.videolan.org/vlc/index.html VLC] web plugin.

When the client uses the controls to change the video source, the server kills the current GStreamer process and launches a new one using the new video source. It then makes the client's page refresh to make the embedded video player use the new stream.

A block diagram of the system is shown below.

[[File:BbWebcamFeed_Block_Diagram.png|400px|Web Cam Feed Block Diagram]]

== Work Breakdown ==

*Research- Research took up the bulk of our time and effort on this project due to the obscure nature of video streaming on the web using HTML5 and related tools. Most sources online advise you to use a plugin or third party software and treat the idea of using Javascript of HTML5 for this task as a taboo subject.
**GStreamer Implementation- John Lobdell investigated using GStreamer to accomplish this project. This implementation in the end proved effective and the easiest to implement.
**HTML5/JavaScript Implementation - Alex Drane investigated using a pure HTML5 implementation in order to not require anything to be done by the user to view the video streams. From initial research this appeared to be something that could be done quite easily. After considerable research wading through the draft standards that have been developed I found very little sample code or examples that pertained to remote video viewing. The easiest implementation I found was using it to create a 1-to-1 chat application. This is not suitable for our needs.

*Program Creation- John Lobdell used his research to get GStreamer to stream a video or camera input onto port 8080 that could then be read by the VLC Media Player on a remote computer. The further integration of this into a program was done with the introduction of the VLC-plugin in an HTML document. The final program was jointly compiled by both John and Alex.

The program creation went quite fast after a working method was identified by John. Then it was a matter of putting the pieces together. The program consists of a node.js client server using the example provided in the examples/node.js folder, which provides the HTML server and controls for which video to stream. We embedded the VLC viewer into the page and pointed it to the location where the video would be streamed by an external function call in the .js file. This allowed for a simplified approach to running the needed utilities without having to port code into the Javascript language.

== Future Work ==

Adding video capture would add true security camera capabilities to this system. In addition adding motion detection into the video selection stream would be interesting. Though this might be too much for the xM's hardware.

Having a webpage that displayed all of the video feeds at once would also be an interesting feature but this could over tax the XM's hardware or internet connection.

Figuring out how to implement this project with only HTML5 and make it so that no plugin is required by the end user was Alex's original plan but the maturity of the knowledge base for HTML5 is not adequate to accomplish this task at this time. But in the future when many of the draft standards are finished this project could be implemented without the VLC plugin.

Solving the interesting problem with the random stream failure. This issue arises when switching between streams. Occasionally the video receiver does not receive the stream even though the stream is playing across the network. From experimentation we found that as cameras were added the performance of the entire program greatly decreased. Since we only access one camera at a time the only explanation we could find was that the OS was devoting resources to the devices when they were connected thus creating a much greater overhead as cameras were added. When the cameras were disconnected the performance returned to their previous levels. With four cameras operating a noticeable increase in stream failures was observed. With only two cameras operating about 1/5 of attempts would be unsuccessful. With four cameras the failure rate was significantly higher (as much as 1/3 of attempts would fail). One possible explanation of this is the overhead causing a slow down in setup time for the video out thread compared to the load up time of the browser. While this is set up to go first if the system hanged due to lack of resources this could cause the video stream to start after the HTML file stopped looking for it. Occasionally the camera just won't turn on. We have found that signaling it again usually fixes the problem without much effort. After trying to figure out what was causing the problem we could not definitively pin down the root cause of the problem and we found no simple or effective solution for it but would like to see it fixed.

The server should automatically detect its external IP and then use it to direct the client's VLC plugin to the video stream.

The video should stream through UDP rather than TCP. UDP would have better performance, and data loss is not a major concern for low-resolution video.

Audio can be added to the video stream.

== Conclusions ==

This project was quite surprising by how difficult it is to do using the new HTML5 standards. Through the research we learned that there were currently no simple implementations of what we wished to do with this project. We had originally assumed that something as common as video streaming would have a direct implementation in the new standard but in fact it is far more restricted then we expected. By splitting each of our focuses during the research stage we were able to research the use of the bleeding edge of development and the use of the common implementation and then whoever found an implementation that worked first would allow the project to progress. In addition our parallel research gave us greater insight into the potential ways of accomplishing this task then if we had both focused on the HTML5 implementation and did not allow the project to reach a dead end as it would have if we had both focused on the HTML5 method.

In the end we did settle on using the vlc-plugin to capture the outgoing stream that John setup using gstreamer. This worked exactly as we wished it to without all of the syntax fighting that took place when trying to port the HTML5 sample code into code we had the codex's for(i.e. websocket to socket.io syntax Note: websocket wanted a Microsoft related XML file which after searching for could not be found when we tried to just use websocket).

Many of the ideas listed in Future Work would be amazing addon's to the project that would greatly expand and enhance this projects implementation.

{{YoderFoot}}

ECE497 BeagleBone PRU

2013-05-18T16:17:31Z

Yoder: Removed grade. Moved to Fall2012

[[Category:ECE497Fall2012 |Project]]
{{YoderHead}}

Team members: [[user:Correlbn|Bryan Correll]], [[user:Millerap|Andrew Miller]], [[user:Ngop|Peter Ngo]], [[user:Popenhjc|James Popenhagen]]

== Grading ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

== Executive Summary ==

For this project, the objective is to explore the PRU, Programmable Realtime Unit, of the BeagleBone, looking at both the limitations of implementation and how to implement tasks such as handling pulse width modulation. The PRU is a part of the processor that runs at 200MHz (5ns per instruction), and is separate from the operating system all together, making it more efficient at accessing I/O pins. The project is more research intensive, as opposed to implementation intensive, and serves to bring together all of the sources found on the BeagleBone's PRU into one abbreviated document with examples of how to use it and the potential for extra projects. The ultimate goal here is to walk through step by step leading to the representation of a sinusoidal wave using pulse width modulation accessed from PRU and play the produced wave through a speaker.

As of now we have gathered information about the PRU, found memory locations that can be edited on the PRU and in C so that we can interact with functions outside of the PRU's capabilities, and implemented code on the PRU that simulates a pulse width modulation on a GPIO pin. We were also able to produce an approximated sinusoidal output on the GPIO pin using pulse width modulation at a specific frequency. For each of these there is an example to follow describing how each part works, and listing any resources to look at to find out more.

We were hoping to potentially look into reading an analog input and producing it as an approximated output using the pulse width modulator, but this ended up being to optimistic of a goal. This would be an interesting thing to explore for a project that expands upon this.

== Installation Instructions ==

The Git Hub is on the following link:

*https://github.com/millerap/AM335x_PRU_BeagleBone
*Hardware: Some LEDs for messing with the GPIO pins and a speaker for listening to PWM approximated sine wave.

Note: When implementing the pulse width modulation, you may want to bias the wave around 0V instead of 1.65V. If this is the case, you may want to use a summing circuit which will require an Op-Amp, a 2kohm and 1kohm resistor, and 2 resistors of the same value (Higher values preferable for lower power consumption), which will need to be connected as shown where V1 is your pwm voltage, V2 is your -1.65V bias, and V3 is unused:

[[File:SummerCicuit.png|Non-Inverting Summer Circuit]]

Unless you desire a louder output than capable with simple I/O pins, there is no additional hardware needed.

== User Instructions ==

'''Always''' run the following before doing anything with the PRU:
beagle$ '''modprobe uio_pruss'''

This can be activated anywhere on the BeagleBone and activates the PRU module in the kernel so that its memory and all of its components are accessible.

Note: modprobe uio_pruss is BeagleBone specific and will not be found on a host computer. Also, if you do not do this instruction before following the rest of the instructions you may run into segmentation faults when trying to initialize the PRU.

Which image are you using? The modprobe works for me, but may depend on the image.

== Finding Where to Access Things ==

There are many locations in memory that are needed to access specific I/O pins on the BeagleBone. Some of these I/O pins can be found here:
*[http://www.ti.com/lit/ug/spruh73f/spruh73f.pdf SPRUH73f pdf]

The following are not found in the file, but are good addresses to know when accessing MUXs:

gpmc_a2:
memory location: gpmc_a2.gpio1_18 (0x44e10848/0x848 = 0x0027), b NA, t NA
mode: OMAP_PIN_INPUT_PULLDOWN | OMAP_MUX_MODE7
signals: gpmc_a2 | gmii2_txd3 | rgmii2_td3 | mmc2_dat1 | gpmc_a18 | pr1_mii1_txd2 | ehrpwm1A | gpio1_18

gpmc_a3:
memory location: gpmc_a3.gpio1_19 (0x44e1084c/0x84c = 0x0027), b NA, t NA
mode: OMAP_PIN_INPUT_PULLDOWN | OMAP_MUX_MODE7
signals: gpmc_a3 | gmii2_txd2 | rgmii2_td2 | mmc2_dat2 | gpmc_a19 | pr1_mii1_txd1 | ehrpwm1B | gpio1_19

gpmc_ad8:
memory location: gpmc_ad8.gpio0_22 (0x44e10820/0x820 = 0x0027), b NA, t NA
mode: OMAP_PIN_INPUT_PULLDOWN | OMAP_MUX_MODE7
signals: gpmc_ad8 | lcd_data23 | mmc1_dat0 | mmc2_dat4 | ehrpwm2A | pr1_mii_mt0_clk | NA | gpio0_22

gpmc_ad9:
memory location: gpmc_ad9.gpio0_23 (0x44e10824/0x824 = 0x0027), b NA, t NA
mode: OMAP_PIN_INPUT_PULLDOWN | OMAP_MUX_MODE7
signals: gpmc_ad9 | lcd_data22 | mmc1_dat1 | mmc2_dat5 | ehrpwm2B | pr1_mii0_col | NA | gpio0_23

== Building and Running the GPIO_PWM_PRU Example ==

This example is located in the GPIO_PWM_PRU directory in the AM335x_PRU_BeagleBone git repository, and can be pulled with the following:
beagle$ '''git clone git://github.com/millerap/AM335x_PRU_BeagleBone'''

This example uses the gpio and delay loops to approximate a PWM using the user LEDs on the BeagleBone. It is based on an example provided by Lyren Brown and documented by boxysean at
http://blog.boxysean.com/2012/08/12/first-steps-with-the-beaglebone-pru/

In GPIO_PWM_PRU all of the complicated Makefiles and directories used to make a multitude of examples at once have been stripped away to allow the user to compile one individual program that will run on the PRU.

The readme.txt file in the GPIO_PWM_PRU directory provides a walkthrough for compiling and running blinker on the BeagleBone.

The first step to compiling a program for the PRU is to make sure prussdrv.c is made and up to date. This is the file provided by TI that contains all of the C functions that allow for communication with the PRU. To do this, do the following:
beagle$ '''cd <directory>/AM335x_PRU_BeagleBone/GPIO_PWM_PRU/interface'''
beagle$ '''export CROSS_COMPILE=""'''
beagle$ '''make'''

CROSS_COMPILE is specified as "" because this is running on the BeagleBone itself and the Makefile is setup to defaultly cross compile the code from another linux machine.

Once this is completed, the pasm_source must be set for the BeagleBone's linux operating system:
beagle$ '''cd ../utils/pasm_source'''
beagle$ '''./linuxbuild'''

'''Note: The above instructions need to be done for every time the BeagleBone boots up and these directories should be included with any code that you write for the PRU'''

Now, the BeagleBone is ready to compile the example code. Navigate to the example's root directory again:
beagle$ '''cd ../../'''
beagle$ '''make CROSS_COMPILE=""'''

This will compile the blinker.c file and output it to the bin folder. After this point, the assembly file needs to be compiled into a .bin file. This is done in the bin folder.
beagle$ '''cd bin'''
beagle$ '''make'''

Now, there should be a blinker.bin file in the folder. running the blinker executabile will put the blinker.bin file on the PRU and start it running. Use the following:
beagle$ '''./blinker'''

== How the Assembly Code Works ==

//in the overview talk about the period being 5ns

In the assembly file blinker.p:

Registers r5 and r6 are the duty_cycle and period respectively. The duty_cycle is a number smaller than the period that the accumulator r4 counts up to before setting the output to zero. When the r4 = period, r4 resets and the output is set to 1. This gives the following for for OnTime and OffTime.

SecondsPerCycle = 5*10^-9
OnCycles = 2 + (duty_cycle)*3 + 2
OffCycles = 2 + (period - duty_cycle)*3 - 1 + 2
TotalCycles = 7 + (period)*3

These equations can be used to create a very exact PWM output by setting duty_cycle and period to the values you wish to use. The code that was compiled and run above has a period of about a second and a duty cycle of about 50%.

There are a few macros defined at the beginning of the program. These macros are the location of GPIO1's memory space, the location of its set registers and the location of its clear registers. The BeagleBone's GPIO pins must be turned off and on using these two different memory locations. Setting the set register to 0 does not turn off its respective GPIO pin.

r2 stores the value that is going to be written to either set or clear gpio. r3 stores the address that r2 will be written to. within the first 3 lines of PWM_ON these values are set such that r2 will turn on the user LEDs. The instruction that actually turns it on is SBBO. This takes the value of r2 and writes it to memory location r3 with an offset of 0.

Here is a complete guide to the [http://processors.wiki.ti.com/index.php/PRU_Assembly_Instructions PRU's Assembly Instructions] from TI

== How the C Code Works ==

The following information can be found on TI's PRU Linux Application Loader API Guide wiki:
*[http://processors.wiki.ti.com/index.php/PRU_Linux_Application_Loader_API_Guide#prussdrv_map_prumem C PRU instructions]

This lays out every function that can be used in the C code as well as an explanation of its functionality.

The blinker.c file is a direct port of the PRU initialization code from TI. Putting the two side by side, the only difference between the two is the name of the bin file that is used for the exec function.

The code first initializes the PRUSS, Programmable Realtime Unit Subsystem or the entire system of two PRUs, an interrupt controller (INTC), and associated memory ([http://processors.wiki.ti.com/index.php/Programmable_Realtime_Unit_Subsystem PRUSS]), by allocating memory for it using the prussdrv_init() function. It then initializes memory mapping for the PRU using the prussdrv_open() function. All of the intc functions are used for interrupt communication between the ARM and the PRU. This code is not utilized by the examples in this page.

Similar to the exec function in C, the prussdrv_exec_program () function overlays the IRAM (Instruction RAM) portion of the PRUSS with the bin file that was created from blinker.p. The first field of prussdrv_exec_program needs a PRU number, which is either 0 or 1 depending on which PRU core is being used. In this case, PRU0 is executing blinker.bin. The second field is the path to the bin that will be put into the PRU's IRAM.

The next section waits on event 0 from the PRU to signal the C program that it has completed its execution. This, again, was not implemented, but writing the appropriate bit to the r31 register would cause the C program to continue. As it is, the program stalls at this point until SIGINT is received.

If the correct event were received, the next function is used to halt the PRU's execution then it would release the PRUSS clocks and disable the prussdrv module.

== Sending an array to the PRU ==

The initialization code provided by TI has a handy function for passing an array to the PRU. Each of the PRU cores have an 8kb data ram associated with them, and that data space can be populated from an external C program. The next example will make use of this function to pass different PWM duty cycles to the PRU. This will be largely based around the following function:

int prussdrv_pru_write_memory (unsigned int pru_ram_id, unsigned int wordoffset, unsigned int *memarea, unsigned int bytelength);

pru_ram_id can take on one of 4 values, and are as follows:

PRUSS0_PRU0_DATARAM
PRUSS0_PRU1_DATARAM
PRUSS0_PRU0_IRAM
PRUSS0_PRU1_IRAM

Here, each of the PRUs have both an Instruction RAM and a DATARAM section. DATARAM for PRU0 is found in the memory locations 0x0 - 0x2000, and DATARAM for PRU1 is found in the memory locations 0x2000 - 0x4000.

wordoffset is an offset in words (4 bytes) from the base memory location, pru_ram_id.

memarea is a pointer to an array of unsigned ints (also 4 bytes) that will be passed onto the PRU.

bytelength is the number of bytes to write to the PRU.

For more information on using C to initialize the PRU visit [http://processors.wiki.ti.com/index.php/PRU_Linux_Application_Loader_API_Guide#prussdrv_map_prumem TI's PRU Linux Application Loader API Guide]

== Building and Running the Sin_Approximation Example ==

This example uses a modified version of the GPIO_PWM_PRU example to change the duty cycle every period such that the average voltage approximates a sin wave. Navigate to the pwm_sin directory and take a look at the C code. Its nearly identical to the previous code except for a few small differences. The first difference is that it opens and edits two files to export GPIO0_7 and turn it into an output.

The next change is that the prussdrv_pru_write_memory command discussed above is used to push an array containing duty cycles onto the DRAM for PRU0. The duty cycles are approximated using a the sin function from the math.h header file. Here is why:
(VCC*(on_time)+0*(off_time))
---------------------------- = VCC*duty_percent
period
.
VCC*duty_percent = Va
.
Va = VCC*Sin(2*PI*f*t/fs)
.
VCC*duty_percent = VCC*sin(2*PI*f*t/fs)
.
duty_percent = sin(2*PI*f*t/fs)

Looking at the assembly code, we see a similar PWM control as before, but this time it is reading the duty cycles from memory. The coding to do this is a little more complicated due to precise measuring for the sampling frequency, but because this is being run on PRU0, DRAM starts at 0x0. If you feel that you need to change the sampling frequency at any point here's a bit on how to calculate the amount of instructions you need to delay in total.

sample_period = 1/sample_frequency
.
sample_period/(number_instructions_delay_loop*5ns) = total_number_instructions_to_delay_per_period
.
Then count the amount of instructions before or after the loop and nock off that many instructions to delay. This will of course
need to be accounted for in the duty cycle, and some sampling frequencies may not offer all duty_percentages.
.
duty_percent = number_on_instruction_delay/number_off_instruction_delay
.
number_on_instruction_delay + number_off_instruction_delay = total_number_instructions_to_delay_per_period
.
->(duty_percent + 1)*total_number_instruction_to_delay_per_period = number_on_instruction_delay

Of course a few other numbers will have to be adjusted, such as the number of samples to read from memory. Because it has to read in 4 bytes of data, this will end up being:
total_number_instructions_to_delay_per_period*4+4
This way the number will reset to 0 as soon as it goes over the limit of memory to be read.

To build this example, follow the same procedure as before, and wire GPIO7 (Pin 42) of P9 through a speaker to ground. The output produced will be start as a 367Hz approximation and can be changed by putting a number into the terminal (67 to 66000) and pressing enter (NOTE:Text may mess it up. So, DON'T use text!). All of the sampling for 133kHz sampling is now taken care of for any frequency wave mentioned in the previous sentence.

== Highlights ==

During the project we were able to get an approximated 880Hz sine wave to play by changing a pulse width modulation duty cycle to approximate a dc voltage output, as you would with an LED dimmer. You can view this in action along with a helpful tip in the youtube video:

*[http://www.youtube.com/watch?v=6ytju0bkkiQ&feature=youtu.be PWM Demo].
*[http://www.youtube.com/watch?v=aFep70xN2j4 PWM Sine Wave Approximation Example]

== Theory of Operation ==

In the first examples, you can see that the GPIO can be toggled on and off simply by editing locations in memory from the PRU. You simply set how long you want the LED to be on and how long you want the LED to be off, and delay the time between on and off to create the desired latency.

In the following example, the premise changes slightly. The operation of our code is simple, the PRU offers precise instruction delay of 5ns per instruction. With this we were able to create a delay of instructions that would be a sampling frequency, and in between this delay of instructions we were able to have a set amount of instructions for which the GPIO was on, and a set amount where the GPIO was off. Also, memory could be set from a C program, and then read by the PRU. This came in handy when approximating the sine wave because C offers the math.h header file that has the sin function included and can give approximate numbers to send to the PRU. The amount of delay on and off could be set dynamically every time the loop began by reading the next bit of data stored in memory, thus creating an average voltage that approximated a playable sine wave.

Refer to How the C Code Works, How the Assembly Code Works, and Building and Running Sin_Approximation for more details.

== Work Breakdown ==

'''Milestones'''

10/22: We should have all research done. Update documentation with every Milestone.

10/26: We should be able to show something, an example or simple implementation.

10/29: Ability to send different lengths to turn on an LEDs.

10/31: Ability to send different lengths to multiple LEDs.

11/2: We should be able to demo our overall work, possibly have some things to fix before presentation.

11/4: Finalize presentation

11/6-11/9: Presentation

'''What was done and Who did it'''

Research and Documentation: Andrew, Bryan, James, Peter

Simple Implementation of a blinking LED: Andrew, Bryan, James, Peter

PWM Implementation: Andrew

Sinusoidal Approximation: James

Wiki Editing and Organization: Andrew, Bryan, James, Peter

'''Research'''

Most of our research has come from internet resources listed below:
*[http://elinux.org/Ti_AM33XX_PRUSSv2 TI PRU Resources]
*[http://blog.boxysean.com/2012/08/12/first-steps-with-the-beaglebone-pru/ Example for Running Code on the PRU]
*[http://processors.wiki.ti.com/index.php/PRU_Assembly_Instructions PRU Assembly Instructions]
*[http://processors.wiki.ti.com/index.php/PRU_Linux_Application_Loader_API_Guide#prussdrv_map_prumem Initializing PRU in C]
*[http://www.ti.com/lit/ds/symlink/am3358.pdf AM335X Datasheet]

== Future Work ==

For future work there are a few interesting features that we were not able to get to due to time limit and the amount of research needed to begin with. First, we found difficulty in accessing things such as the PWM and analog in ports. These could be further explored given the documents that we have dug up, and some exploration on Google. Second, we wanted to read audio from the analog input and adjust the duty_cycle of the PWM accordingly to have approximate audio output which is the next step to what we have done here. Third, we wanted to explore interrupts on the PRU, but were unable to find enough documentation to get an example working.

So, PWM, analog in, audio capabilities, and interrupts are the possible things to look into. Also, any other time critical operations can be explored further with the BeagleBone PRU because it has a delay of exactly 5ns for every instruction.

== Conclusions ==

So, if you need precise timing, or more rapid access to a certain GPIO pin, this is a route you might want to look into. There are a few suggestions listed above that might be interesting to see come out of using the PRU. However, if you do not require precisely timed events or faster access to GPIO pins, you might want to consider just using C on the main processor. Much of the information needed to access certain parts of the PRU and the hardware from the PRU is either very vague, or very difficult to dig up, and because the PRU is not widely used, it is difficult to find people that can offer information on the topic.

{{YoderFoot}}

ECE497 Beagle VNS

2013-05-18T16:16:16Z

Yoder: Removed grade. Moved to Fall2012

[[Category:ECE497Fall2012 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we are able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encode the recording into a mp3 file and send it via an email attachment to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use, who to send the email message too, as well as what text to populate the subject and body field with.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The node.js server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]
[[File:BeagleVNS_Door_Bell.jpg|thumb|right|A door bell button is a good idea]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email, and that we have been working under Python 2.7 and did not need to modify our code for version 3.0 syntax.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*'''Node.js'''

::Node.js is a tool for quickly make web or browser based interfaces for networking with the beagle or any comparable platform.

:: Installation instructions can be found here: [[ECE497 Notes on node.js | ECE497 Notes on node.js]]

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::Node.js is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Restart the Network'''
:::If you cannot grab an ip address from a dns server when the A5 image initially boots up. Run the following command in order to restart the network service

beagle$ '''/etc/init.d/networking restart'''

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Beagle VNS Application'''

::: In order to run the Beagle VNS Application you will need go to the C-Programs Directory

beagle$ '''cd ~/BeagleBoardVNS/C-Program/'''

::: Once you are in this directory, you will need to compile the application.

beagle$ '''make clean; make'''

::: Now you can run the application. There is currently only a debug version of the application. This verision will print out debug information which is helpful to see what is going on.

beagle$ '''./beagleVNSApp_DEBUG'''

::: You can also start the node.js server to edit the configuration file. Simply run the command below in the BeagleBoardVNS destroyer and then point your browser to the beaglebone's port 8081 with a URL or host name, i.e: beagleVNS.local:8081

beagle$ '''node BeagleBoardVNS.js'''

::: Note that you can change your host name by editing this file: /etc/hostname. For example:

beagle$ '''nano /etc/hostname'''

== Highlights ==

{{#ev:youtube|k7yUmo1zc0Q}}

[http://www.youtube.com/watch?v=k7yUmo1zc0Q BeagleVNS YouTube Video Demo]

[http://www.youtube.com/embed/k7yUmo1zc0Q BeagleVNS YouTube Video Demo]

== Theory of Operation ==

[[File:BeagleVNSDiagram.jpg|640px|thumb|right|BeagleBone]]

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio or achieve files locally
# Capture video along with audio or capture image upon button press
# Voice-To-Text using Google Voice API
# Low Power Mode for longer battery life using interupts
# Release alsa device for other aplications when not in use
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions to the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Notes

2013-05-18T16:12:54Z

Yoder:

[[Category:ECE497 |Notes]]

You can find my various notes (works in progress) [[:Category:ECE497Notes | here]]

ECE497 Notes

2013-05-18T16:11:32Z

Yoder: Created page with "You can find my various notes (works in progress) here"

You can find my various notes (works in progress) [[:Category:ECE497Notes | here]]

Category:ECE497Notes

2013-05-18T16:11:08Z

Yoder: Created page with "This is collection of notes on things I'm still trying to figure out."

This is collection of notes on things I'm still trying to figure out.

ECE497 Notes on systemd

2013-05-18T16:06:45Z

Yoder:

[[Category:ECE497Notes |sys]]

{{YoderHead}}
The new BeagleImages use [http://www.freedesktop.org/wiki/Software/systemd/ systemd] for user space initialization.

[https://www.linux.com/learn/tutorials/524577-here-we-go-again-another-linux-init-intro-to-systemd/ Here], [https://www.linux.com/learn/tutorials/527639-managing-services-on-linux-with-systemd/ here] and [https://www.linux.com/learn/tutorials/539856-more-systemd-fun-the-blame-game-and-stopping-services-with-prejudice/ here] are some tutorials that look good.

[http://www.freedesktop.org/wiki/Software/systemd/FrequentlyAskedQuestions Here] is information on runlevels.

[http://crashmag.net/useful-systemd-commands Here] is a nice list of useful commands.

[http://www.freedesktop.org/wiki/Software/systemd/TipsAndTricks Tips and Tricks]

=== Gadgets ===
I found these gadgets
network-gadget-init.service storage-gadget-init.service

in

/lib/systemd/system

/usr/bin/update-image-info-on-mmcblk0p1.sh

is what creates the info.txt file.

beagle$ '''mount /dev/mmcblk0p1 /mnt'''

Here's a way to see what gadgets are out there

beagle$ '''systemctl --all | grep gadget'''
sys-devi...et-usb0.device loaded active plugged /sys/devices/platform/omap/musb-ti81xx/musb-hdrc.0/gadget/net/usb0
network-...t-init.service loaded active exited Start USB Ethernet gadget
storage-...t-init.service loaded inactive dead Start usb mass storage gadget
udhcpd.service loaded active running DHCP server for USB0 network gadget

or

systemctl --all '''--full''' | grep gadget
sys-devices-platform-omap-musb\x2dti81xx-musb\x2dhdrc.0-gadget-net-usb0.device loaded active plugged /sys/devices/platform/omap/musb-ti81xx/musb-hdrc.0/gadget/net/usb0
network-gadget-init.service loaded active exited Start USB Ethernet gadget
storage-gadget-init.service loaded inactive dead Start usb mass storage gadget
udhcpd.service loaded active running DHCP server for USB0 network gadget

Where
'''network-...t-init.service''' = '''network-gadget-init.service'''
'''storage-...t-init.service''' = '''storage-gadget-init.service'''

'''/etc/udhcpd.conf''' is what assigned 192.168.7.1 to the host computer.

To stop the ethernet over USB and start the storage over USB for the current session

beagle$ '''/bin/systemctl stop storage-gadget-init.service'''
beagle$ '''/bin/systemctl start network-gadget-init.service'''

To go the other way:

beagle$ '''g-ether-start-service.sh'''

To keep the storage gadget from running on boot up. (I'm still checking this.)

beagle$ '''systemctl disable storage-gadget-init.service'''

{{YoderFoot}}

ECE497 Notes on fritzing

2013-05-18T16:06:13Z

Yoder:

[[Category:ECE497Notes |fr]]
{{YoderHead}}

[http://fritzing.org/ Fritzing] looks like a good way to draw BeagleDiagrams.

[http://engineersofthecorn.blogspot.com/2012/06/fritzing-part-for-beaglebone.html Here's] a bone.

{{YoderFoot}}

ECE497 Notes on Upgrading to 3.0

2013-05-18T16:05:54Z

Yoder:

[[Category:ECE497Notes |up]]
{{YoderHead}}

I've been running the 2.6.28 kernel for a while now and I think it's time to upgrade to 3.0.

== Getting the SD image ==
=== xM ===

There are a bunch of SD card images [http://www.angstrom-distribution.org/demo/beagleboard/ here]. I downloaded '''Angstrom-TI-GNOME-image-eglibc-ipk-v2012.01-core-beagleboard-2012.01.11.img.gz''' and was able to get it to boot, however nothing shows in the DVI display. (I tried '''Angstrom-Cloud9-IDE-eglibc-ipk-v2011.11-core-beagleboard-2011.11.21.img.gz''' and it booted but didn't start the network correctly, so I'm not using.)

beagle$ '''uname -a'''
Linux dhcp-137-112-41-101 3.0.14+ #1 Thu Dec 22 09:53:00 CET 2011 armv7l GNU/Linux
beagle$ '''cat /proc/cmdline'''
console=tty0 mpurate=auto buddy=none buddy2=none camera=none vram=12M
omapfb.mode=dvi:640x480MR-16@60 omapdss.def_disp=dvi
root=/dev/mmcblk0p2 ro rootfstype=ext3 rootwait

=== bone ===

==== From circuitco ====

I'm presently running the SD image that comes with [http://circuitco.com/support/index.php?title=BeagleBone_A6_Image_06.18.2012 BeagleBone Rev A6]. [http://circuitco.com/support/index.php?title=BeagleBone_A6_Image_06.18.2012 Release Notes].

host$ '''cd Downloads'''
host$ '''wget http://circuitco.com/support/files/BeagleBone-A6/BeagleBone_Rev_A6_Production_06_18_2012.7z'''
host$ '''sudo apt-get install p7zip-full'''
host$ '''7z e BeagleBone_Rev_A6_Production_06_18_2012.7z''' (takes about 2.5 minutes)
host$ '''sudo dd if=BeagleBone_Rev_A6_Production_06_18_2012.img of=/dev/sd''X'' bs=8M''' (takes about 6.5 minutes)

beagle$ '''uname -a'''
Linux beaglebone 3.2.18 #1 Thu Jun 14 23:26:20 CEST 2012 armv7l GNU/Linux
beagle$ '''cat /proc/cmdline'''
console=ttyO0,115200n8 run_hardware_tests quiet root=/dev/mmcblk0p2 ro
rootfstype=ext4 rootwait ip=none

Hmmmm.... It's the same kernel as the one from below.

==== From Angstrom ====
There is one bone image [http://downloads.angstrom-distribution.org/demo/beaglebone/ here] so I'm running with '''Angstrom-Cloud9-IDE-GNOME-eglibc-ipk-v2012.05-beaglebone-2012.06.18.img.xz '''

Following the instructions on the site I do:
host$ '''sudo -s'''
host# '''time xz -dkc Angstrom-Cloud9-IDE-eglibc-ipk-v2011.10-core-beaglebone-r0.img.xz > /dev/sdX'''
real 17m27.313s
user 1m54.391s
sys 0m9.621s
host# '''exit'''

beagle$ '''uname -a'''
Linux beaglebone 3.2.18 #1 Thu Jun 14 23:26:20 CEST 2012 armv7l GNU/Linux
beagle$ '''cat /proc/cmdline'''
console=ttyO0,115200n8 run_hardware_tests quiet root=/dev/mmcblk0p2 ro
rootfstype=ext4 rootwait ip=none

== Updating and Upgrading ==

Here's what I'm doing on both the bone and xM.
I did the following to make sure the image is up to date.

beagle$ '''opkg update'''
beagle$ '''opkg install ssh-keygen'''
real 0m32.488s
user 0m23.530s
sys 0m0.380s
beagle$ '''ssh-keygen -t rsa -t rsa -C "Mark.A.Yoder@Rose-Hulman.edu"'''
Generating public/private rsa key pair.
Enter file in which to save the key (/home/root/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/root/.ssh/id_rsa.
Your public key has been saved in /home/root/.ssh/id_rsa.pub.
The key fingerprint is:
1d:21:25:ec:ef:14:d8:7f:1b:81:42:ab:f6:43:b5:15 Mark.A.Yoder@Rose-Hulman.edu
The key's randomart image is:
+--[ RSA 2048]----+
| .o.o |
| .o.. E |
| . +.. . . |
| o.=.o o |
| So.= o . |
| o + o o |
| . = . o |
| + . |
| . |
+-----------------+
beagle$ '''time git clone git://github.com/MarkAYoder/BeagleBoard-exercises exercises'''
real 14m7.983s
user 1m8.420s
sys 0m23.040s
beagle$ '''opkg install alsa-dev'''

The last command loads the alsa .h files. The library files there, but one symbolic link is missing, so I did:

beagle$ '''cd /usr/lib'''
beagle$ '''ln -s libasound.so.2.0.0 libasound.so'''

beagle$ '''time opkg install i2c-tools-dev'''
real 0m38.284s
user 0m23.450s
sys 0m0.280s

=== Needed for older version ===
I needed these for an older version, but not the current one.

beagle$ '''opkg install gcc gcc-symlinks libgcc-s-dev -force-overwrite'''

This may do the gcc install too.

beagle$ '''opkg install task-sdk-target''' (took about 8 minutes)

Also did
beagle$ '''opkg install evtest'''

Here's what's needed to run the Flot demo
beagle$ '''opkg install nodejs''' (took about 1 minute)
beagle$ '''opkg install alsa-utils''' (took about 1 minute)

== What's on a fresh install ==

Here's what I found installed on a fresh image.

=== xM ===

=== bone ===

beagle$ '''opkg list_installed > /tmp/installed'''
beagle$ '''wc /tmp/installed'''
2279 6837 114831 /tmp/installed
<pre>
abiword - 2.8.6-r2
alsa-conf-base - 1.0.25-r1
alsa-states - 0.2.0-r2
alsa-utils - 1.0.25-r2
alsa-utils-aconnect - 1.0.25-r2
alsa-utils-alsaconf - 1.0.25-r2
alsa-utils-alsactl - 1.0.25-r2
alsa-utils-alsaloop - 1.0.25-r2
alsa-utils-alsamixer - 1.0.25-r2
alsa-utils-alsaucm - 1.0.25-r2
alsa-utils-amixer - 1.0.25-r2
alsa-utils-aplay - 1.0.25-r2
alsa-utils-aseqdump - 1.0.25-r2
alsa-utils-aseqnet - 1.0.25-r2
alsa-utils-iecset - 1.0.25-r2
alsa-utils-midi - 1.0.25-r2
alsa-utils-speakertest - 1.0.25-r2
angstrom-clearlooks-theme-enable - 1.0-r0
angstrom-feed-configs - v2012.05-r0
angstrom-gdm-autologin-hack - 1.0-r1
angstrom-gnome-icon-theme-enable - 1.0-r1
angstrom-task-boot - 1.0-r4
angstrom-task-gnome - 1.0-r12
angstrom-version - 2:v2012.05-r11
aspell - 0.60.6.1-r1
attr - 2.4.46-r4
attr-dev - 2.4.46-r4
autoconf - 2.68-r7
automake - 1.11.2-r3
avahi-daemon - 0.6.31-r2.0
avahi-systemd - 0.6.31-r2.0
avahi-utils - 0.6.31-r2.0
base-files - 3.0.14-r87
base-passwd - 3.5.24-r0
bash - 4.2-r2
bash-dev - 4.2-r2
bc - 1.06-r1
beaglebone-capes - 1.0-r3
beaglebone-getting-started - 1.0-r21
beaglebone-tester - 1.0-r17
bigreqsproto-dev - 1:1.1.1-r0
binutils - 2.20.1-r9
binutils-symlinks - 2.20.1-r9
bison - 2.5-r1
bison-dev - 2.5-r1
bluez4 - 4.99-r1
bonescript - 1.0-r15
bonnie++ - 1.03c-r0
busybox - 1.19.4-r6
busybox-syslog - 1.19.4-r6
busybox-udhcpc - 1.19.4-r6
bzip2 - 1.0.6-r5
bzip2-dev - 1.0.6-r5
ca-certificates - 20120212-r0
canutils - 4.0.6-r0
cloud9 - 0.6-r1
compositeproto-dev - 1:0.4.2-r0
connman - 0.79-r3
connman-gnome - 0.5-r10
connman-plugin-bluetooth - 0.79-r3
connman-plugin-ethernet - 0.79-r3
connman-plugin-fake - 0.79-r3
connman-plugin-loopback - 0.79-r3
connman-plugin-ofono - 0.79-r3
connman-plugin-wifi - 0.79-r3
connman-systemd - 0.79-r3
connman-tests - 0.79-r3
consolekit - 0.4.5-r9
coreutils - 8.14-r3
coreutils-dev - 8.14-r3
cpp - 4.5-r49+svnr184907
cpp-symlinks - 4.5-r49+svnr184907
cpufrequtils - 008-r3
cracklib - 2.8.18-r4
cracklib-dev - 2.8.18-r4
cronie - 1.4.8-r4
cronie-systemd - 1.4.8-r4
curl - 7.24.0-r0
curl-dev - 7.24.0-r0
damageproto-dev - 1:1.2.1-r0
db - 5.1.19-r4
db-dev - 5.1.19-r4
dbus-1 - 1.4.16-r3.0
dbus-systemd - 1.4.16-r3.0
dbus-x11 - 1.4.16-r3.0
debianutils - 2.30-r0
desktop-file-utils - 0.18-r0
devmem2 - 1.0-r7
diffstat - 1.55-r0
diffutils - 3.2-r0
dropbear - 2012.55-r2
dropbear-systemd - 2012.55-r2
e2fsprogs - 1.42.1-r0
e2fsprogs-badblocks - 1.42.1-r0
e2fsprogs-dev - 1.42.1-r0
e2fsprogs-e2fsck - 1.42.1-r0
eglibc-binary-localedata-en-us - 2.12-r20
eglibc-charmap-ibm850 - 2.12-r20
eglibc-extra-nss - 2.12-r28
eglibc-gconv - 2.12-r20
eglibc-gconv-cp1252 - 2.12-r20
eglibc-gconv-ibm850 - 2.12-r20
eglibc-gconv-iso8859-1 - 2.12-r20
eglibc-gconv-iso8859-15 - 2.12-r20
elfutils - 0.148-r7
enca - 1.9-r0
enchant - 1.6.0-r2
encodings - 1:1.0.4-r2.1
epiphany - 2.30.6-r0
evtest - 1.25-r0
fbset - 2.1-r4
fbset-modes - 0.1.0-r6
file - 5.11-r0
findutils - 4.4.2-r2
firefox - 10.0.2-r2
fixesproto-dev - 1:5.0-r0
flex - 2.5.35-r3
flex-dev - 2.5.35-r3
font-alias - 1:1.0.3-r2.3
font-update-common - 0.1-r1
font-util - 1.3.0-r2.0
fontconfig-utils - 2.8.0-r4
g++ - 4.5-r49+svnr184907
g++-symlinks - 4.5-r49+svnr184907
gadget-init - 1.0-r19
gadget-init-network - 1.0-r19
gadget-init-storage - 1.0-r19
gadget-init-udhcpd - 1.0-r19
gateone - 1.1-r5
gawk - 4.0.0-r1
gawk-common - 4.0.0-r1
gcc - 4.5-r49+svnr184907
gcc-symlinks - 4.5-r49+svnr184907
gconf - 3.2.3-r8
gdb - 7.4-r8.0
gdbserver - 7.4-r8.0
gdk-pixbuf - 2.24.1-r0
gdk-pixbuf-dev - 2.24.1-r0
gdk-pixbuf-loader-gif - 2.24.1-r0
gdk-pixbuf-loader-jpeg - 2.24.1-r0
gdk-pixbuf-loader-png - 2.24.1-r0
gdk-pixbuf-loader-xpm - 2.24.1-r0
gdm - 2.32.2-r7
gdm-systemd - 2.32.2-r7
gedit - 2.30.4-r0
gegl - 0.1.8-r0
gimp - 2.6.11-r1
git - 1.7.10.2-r0
glib-networking - 2.28.7-r2
glibmm - 2.28.2-r1
gnome-bluetooth - 2.32.0-r1
gnome-common - 2.28.0-r1
gnome-common-dev - 2.28.0-r1
gnome-control-center - 2.32.1-r0
gnome-disk-utility - 2.32.0-r1
gnome-icon-theme - 2.31.0-r2
gnome-keyring - 2.32.1-r6
gnome-panel - 2.32.1-r6
gnome-power-manager - 2.32.0-r2
gnome-session - 2.32.1-r2
gnome-settings-daemon - 2.32.1-r5
gnome-system-monitor - 2.28.2-r0
gnome-theme-crux - 2.32.1-r1
gnome-theme-highcontrast - 2.32.1-r1
gnome-theme-highcontrastinverse - 2.32.1-r1
gnome-theme-highcontrastlargeprint - 2.32.1-r1
gnome-theme-highcontrastlargeprintinverse - 2.32.1-r1
gnome-theme-largeprint - 2.32.1-r1
gnome-theme-mist - 2.32.1-r1
gnome-themes - 2.32.1-r1
gnu-config - 20111111-r1
gpe-scap - 1.4-r3
grep - 2.9-r1
gst-ffmpeg - 0.10.13-r4
gst-plugins-base - 0.10.36-r3
gst-plugins-base-adder - 0.10.36-r3
gst-plugins-base-alsa - 0.10.36-r3
gst-plugins-base-app - 0.10.36-r3
gst-plugins-base-apps - 0.10.36-r3
gst-plugins-base-audioconvert - 0.10.36-r3
gst-plugins-base-audiorate - 0.10.36-r3
gst-plugins-base-audioresample - 0.10.36-r3
gst-plugins-base-audiotestsrc - 0.10.36-r3
gst-plugins-base-decodebin - 0.10.36-r3
gst-plugins-base-decodebin2 - 0.10.36-r3
gst-plugins-base-encodebin - 0.10.36-r3
gst-plugins-base-ffmpegcolorspace - 0.10.36-r3
gst-plugins-base-gdp - 0.10.36-r3
gst-plugins-base-gio - 0.10.36-r3
gst-plugins-base-glib - 0.10.36-r3
gst-plugins-base-ivorbisdec - 0.10.36-r3
gst-plugins-base-meta - 0.10.36-r3
gst-plugins-base-ogg - 0.10.36-r3
gst-plugins-base-playbin - 0.10.36-r3
gst-plugins-base-subparse - 0.10.36-r3
gst-plugins-base-tcp - 0.10.36-r3
gst-plugins-base-theora - 0.10.36-r3
gst-plugins-base-typefindfunctions - 0.10.36-r3
gst-plugins-base-videorate - 0.10.36-r3
gst-plugins-base-videoscale - 0.10.36-r3
gst-plugins-base-videotestsrc - 0.10.36-r3
gst-plugins-base-volume - 0.10.36-r3
gst-plugins-base-vorbis - 0.10.36-r3
gst-plugins-base-ximagesink - 0.10.36-r3
gst-plugins-base-xvimagesink - 0.10.36-r3
gstreamer - 0.10.36-r0
gstreamer-dev - 0.10.36-r0
gtk+-dev - 2.24.8-r4
gtk-engine-clearlooks - 2.20.2-r1
gtk-engine-crux-engine - 2.20.2-r1
gtk-engine-glide - 2.20.2-r1
gtk-engine-hcengine - 2.20.2-r1
gtk-engine-mist - 2.20.2-r1
gtk-engine-redmond95 - 2.20.2-r1
gtk-engine-thinice - 2.20.2-r1
gtk-theme-clearlooks - 2.20.2-r1
gtk-theme-crux - 2.20.2-r1
gtk-theme-mist - 2.20.2-r1
gtk-theme-redmond - 2.20.2-r1
gtk-theme-thinice - 2.20.2-r1
gtkmm - 2.20.0-r0.1
gvfs - 1.8.2-r6.0
gvfs-gdu-volume-monitor - 1.8.2-r6.1
gvfsd-ftp - 1.8.2-r6.0
gvfsd-sftp - 1.8.2-r6.0
gvfsd-trash - 1.8.2-r6.0
gzip - 1.4-r1
hdparm - 9.39-r1
hicolor-icon-theme - 0.12-r1
htop - 0.9-r1
i2c-tools - 3.0.3-r0
imagemagick - 6.7.5-r2
inputproto-dev - 1:2.2-r0
iozone3 - 263-r0
iperf - 2.0.4-r0
iproute2 - 3.2.0-r1
iptables - 1.4.12.2-r0
iputils - s20101006-r3
iputils-arping - s20101006-r3
iputils-ping - s20101006-r3
iputils-ping6 - s20101006-r3
iputils-tracepath - s20101006-r3
iputils-tracepath6 - s20101006-r3
iputils-traceroute6 - s20101006-r3
iso-codes - 1.4-r1
iso-codes-locale-en - 1.4-r1
iw - 3.2-r1
kbproto-dev - 1:1.0.5-r0
kernel - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-3.2.16 - 3.2.16-r11o+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-3.2.18 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-boot - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-boot2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-down - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-down2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-down3 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-keyspan-pda - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-new-code - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-new-code-fix - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-trigger-code - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-firmware-trigger-code-fix - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-image-3.2.16 - 3.2.16-r11o+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-image-3.2.18 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-8021q - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-a8293 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad2s1200 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad5064 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad5360 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad5933 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad714x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad714x-i2c - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad714x-spi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad7192 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad7280a - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad7314 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad7414 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad7418 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ad7746 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adcxx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adm1021 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adm1025 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adm1026 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adm1029 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adm1031 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adm9240 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ads1015 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ads7828 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ads7871 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adt7411 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adt7462 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adt7470 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adt7475 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adxl34x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adxl34x-i2c - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-adxl34x-spi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-aes-generic - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-af9013 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ah4 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ah6 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-aircable - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-amc6821 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-aoe - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-appledisplay - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-arc4 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ark3116 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-arp-tables - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-asc7621 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-asix - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-async-memcpy - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-async-pq - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-async-raid6-recov - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-async-tx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-async-xor - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-at76c50x-usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-atbm8830 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ath - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ath6kl - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ati-remote - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ati-remote2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-atxp1 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-au8522 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-authenc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-authencesn - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-b43 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bcm203x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bcm3510 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-belkin-sa - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bfusb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bluetooth - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bma150 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bmp085 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bnep - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bonding - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bpa10x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-brcmfmac - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-brcmutil - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bridge - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-bsd-comp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-btrfs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-btsdio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-btusb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-can-bcm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-can-gw - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-carl9170 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-catc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cbc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cdc-ether - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cdc-ncm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cdc-subset - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cfg80211 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ch341 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cifs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cm109 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cma3000-d0x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cma3000-d0x-i2c - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cp210x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cramfs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cryptoloop - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cs53l32a - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cuse - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx22700 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx22702 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx231xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx231xx-alsa - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx231xx-dvb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx2341x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx24110 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx24113 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx24116 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx24123 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx25840 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cx82310-eth - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cxd2820r - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cypress-cy7c63 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cypress-m8 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-cytherm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-des-generic - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dib0070 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dib0090 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dib3000mb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dib3000mc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dib7000m - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dib7000p - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dib8000 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dib9000 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dibx000-common - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-digi-acceleport - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-crypt - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-flakey - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-log - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-log-userspace - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-mirror - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-mod - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-multipath - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-queue-length - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-raid - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-region-hash - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-round-robin - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-service-time - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-snapshot - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm-zero - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dm9601 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dme1737 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-drm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-drxd - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-drxk - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ds1621 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ds1wm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ds2482 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ds2490 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ds3000 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ds620 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dummy - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dvb-as102 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dvb-core - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-dvb-pll - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-easycap - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ec100 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ecb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-eeprom-93cx6 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-em28xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-em28xx-alsa - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-em28xx-dvb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-emc1403 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-emc2103 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-emc6w201 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-empeg - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ems-usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-eql - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-esd-usb2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-esp4 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-esp6 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-et61x251 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ext2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-f71805f - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-f71882fg - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-f75375s - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-faulty - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ff-memless - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ftdi-elan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ftdi-sio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-funsoft - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-fuse - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-audio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-cdc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-dbgp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-ether - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-ffs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-file-storage - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-hid - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-mass-storage - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-midi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-multi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-ncm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-printer - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-serial - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-webcam - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g-zero - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-g760a - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gadgetfs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-garmin-gps - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-garp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gfs2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gl518sm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gl520sm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gl620a - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gpio-fan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gre - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-benq - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-conex - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-cpia1 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-etoms - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-finepix - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-gl860 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-jeilinj - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-kinect - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-konica - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-m5602 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-main - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-mars - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-mr97310a - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-nw80x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-ov519 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-ov534 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-ov534-9 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-pac207 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-pac7302 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-pac7311 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-se401 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-sn9c2028 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-sn9c20x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-sonixb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-sonixj - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-spca1528 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-spca500 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-spca501 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-spca505 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-spca506 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-spca508 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-spca561 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-sq905 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-sq905c - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-sq930x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-stk014 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-stv0680 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-stv06xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-sunplus - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-t613 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-topro - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-tv8532 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-vc032x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-vicam - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-xirlink-cit - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-gspca-zc3xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-hci-uart - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-hdpvr - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-hidp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-hmac - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-hostap - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-hp4x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-hso - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-hwmon-vid - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-i2400m - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-i2400m-sdio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-i2400m-usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-i2c-algo-bit - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-idmouse - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-iio-dummy - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-iio-dummy-evgen - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-iio-trig-gpio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-iio-trig-periodic-rtc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-iio-trig-sysfs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-imon - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-inet-lro - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-input-polldev - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-int51x1 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-io-edgeport - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-io-ti - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ip-gre - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ip-tables - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ip6-tunnel - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ipaq - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ipcomp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ipcomp6 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ipheth - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ipip - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ipv6 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ipw - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-jvc-decoder - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-kbd-i2c - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-lirc-codec - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-mce-kbd-decoder - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-nec-decoder - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-rc5-decoder - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-rc5-sz-decoder - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-rc6-decoder - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-sony-decoder - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ir-usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ircomm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ircomm-tty - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-irda - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-irda-usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-irlan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-irnet - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-irtty-sir - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-isl6405 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-isl6421 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-isl6423 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-isofs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-it87 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-it913x-fe - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-itd1000 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-iuu-phoenix - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-iwmc3200top - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ix2505v - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-jc42 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-jfs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-joydev - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-kalmia - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-kaweth - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-keucr - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-keyspan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-keyspan-pda - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-keyspan-remote - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-kingsun-sir - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-kl5kusb105 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-kobil-sct - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ks959-sir - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ksdazzle-sir - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-kxtj9 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-l64781 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-legousbtower - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lg-vl600 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lgdt3305 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lgdt330x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lgs8gl5 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lgs8gxx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lib80211 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lib80211-crypt-ccmp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lib80211-crypt-tkip - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lib80211-crypt-wep - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-libceph - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-libertas - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-libertas-sdio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lineage-pem - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-linear - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lirc-dev - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-llc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm63 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm70 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm73 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm75 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm77 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm78 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm80 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm83 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm85 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm87 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm90 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm92 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm93 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm95241 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lm95245 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lnbp21 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lnbp22 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-lp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ltc2978 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ltc4151 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ltc4215 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ltc4245 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ltc4261 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mac80211 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-macvlan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-macvtap - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-max1111 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-max16065 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-max1619 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-max1668 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-max2165 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-max6639 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-max6642 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-max6650 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mb86a16 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mb86a20s - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mc44s803 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mceusb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mcs7780 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mcs7830 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mct-u232 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-md-mod - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-md4 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-md5 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mip6 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mma8450 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mos7720 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mos7840 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-moto-modem - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mpu3050 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-msp3400 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mt2060 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mt20xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mt2131 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mt2266 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mt312 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mt352 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-multipath - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mxl5005s - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-mxl5007t - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-navman - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-nbd - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-nci - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-net1080 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-netconsole - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-nfc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-nfsd - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-nilfs2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ntc-thermistor - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-nxt200x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-nxt6000 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-omapdss - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-omapfb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-oprofile - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-opticon - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-or51132 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-or51211 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-oti6858 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-p54common - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-p54spi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-p54usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-p8022 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-panel-acx565akm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-panel-dvi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-panel-generic-dpi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-panel-n8x0 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-panel-nec-nl8048hl11-01b - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-panel-picodlp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-panel-sharp-ls037v7dw01 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-panel-taal - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-panel-tpo-td043mtea1 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-parport - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pc87360 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pc87427 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pcf8574-keypad - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pcf8591 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pegasus - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pktcdvd - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pl2303 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-plusb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pmbus - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pmbus-core - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pn533 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pn544 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-poseidon - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-powermate - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ppp-async - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ppp-deflate - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ppp-generic - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ppp-mppe - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ppp-synctty - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pppoe - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pppox - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pptp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-prism2-usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-psnap - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pvrusb2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-pwc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-qcaux - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-qcserial - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-qt1010 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-quatech-usb2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-quota-tree - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-quota-v2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-r8712u - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-raid0 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-raid1 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-raid10 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-raid456 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-raid6-pq - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-raw - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-adstech-dvb-t-pci - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-alink-dtu-m - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-anysee - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-apac-viewcomp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-asus-pc39 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-ati-tv-wonder-hd-600 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-ati-x10 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-avermedia - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-avermedia-a16d - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-avermedia-cardbus - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-avermedia-dvbt - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-avermedia-m135a - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-avermedia-m733a-rm-k6 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-avermedia-rm-ks - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-avertv-303 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-azurewave-ad-tu700 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-behold - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-behold-columbus - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-budget-ci-old - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-cinergy - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-cinergy-1400 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-core - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-dib0700-nec - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-dib0700-rc5 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-digitalnow-tinytwin - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-digittrade - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-dm1105-nec - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-dntv-live-dvb-t - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-dntv-live-dvbt-pro - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-em-terratec - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-encore-enltv - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-encore-enltv-fm53 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-encore-enltv2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-evga-indtube - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-eztv - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-flydvb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-flyvideo - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-fusionhdtv-mce - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-gadmei-rm008z - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-genius-tvgo-a11mce - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-gotview7135 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-hauppauge - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-imon-mce - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-imon-pad - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-iodata-bctv7e - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-kaiomy - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-kworld-315u - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-kworld-plus-tv-analog - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-leadtek-y04g0051 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-lirc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-lme2510 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-loopback - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-manli - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-medion-x10 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-msi-digivox-ii - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-msi-digivox-iii - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-msi-tvanywhere - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-msi-tvanywhere-plus - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-nebula - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-nec-terratec-cinergy-xs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-norwood - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-npgtech - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-pctv-sedna - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-pinnacle-color - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-pinnacle-grey - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-pinnacle-pctv-hd - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-pixelview - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-pixelview-002t - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-pixelview-mk12 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-pixelview-new - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-powercolor-real-angel - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-proteus-2309 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-purpletv - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-pv951 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-rc6-mce - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-real-audio-220-32-keys - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-snapstream-firefly - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-streamzap - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-tbs-nec - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-technisat-usb2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-terratec-cinergy-xs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-terratec-slim - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-terratec-slim-2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-tevii-nec - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-tivo - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-total-media-in-hand - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-trekstor - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-tt-1500 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-twinhan1027 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-videomate-m1f - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-videomate-s350 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-videomate-tv-pvr - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-winfast - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rc-winfast-usbii-deluxe - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-redrat3 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-reiserfs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rfcomm - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rfkill - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rfkill-gpio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rfkill-regulator - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rndis-host - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rndis-wlan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rotary-encoder - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rt2500usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rt2800lib - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rt2800usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rt2x00lib - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rt2x00usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rt73usb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rtl8150 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rtl8187 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rtl8192c-common - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rtl8192cu - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rtlwifi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-rts5139 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-s2255drv - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-s5h1409 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-s5h1411 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-s5h1420 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-s5h1432 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-s921 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-saa7115 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-safe-serial - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sch-cbq - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sch-hfsc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sch-htb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sch-multiq - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sch-prio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sch-red - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sch5627 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sch5636 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sch56xx-common - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-scsi-wait-scan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-serqt-usb2 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sha1-generic - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sht15 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sht21 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-si21xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-siemens-mpi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sierra - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sierra-net - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sir-dev - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sisusbvga - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sit - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-slcan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-slhc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-slip - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-smm665 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-smsc47b397 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-smsc47m1 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-smsc47m192 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-smsc75xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-smsc95xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-smscufx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sn9c102 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-snd-hrtimer - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-snd-seq - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-snd-seq-device - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-snd-seq-dummy - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-snd-seq-midi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-snd-seq-midi-event - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sp8870 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-sp887x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-spcp8x5 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-spi-bitbang - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-spi-gpio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-spidev - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ssb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ssu100 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stb0899 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stb6000 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stb6100 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stir4200 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stkwebcam - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-streamzap - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stv0288 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stv0297 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stv0299 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stv0367 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stv0900 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stv090x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stv6110 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-stv6110x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-bic - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-highspeed - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-htcp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-hybla - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-illinois - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-lp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-scalable - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-vegas - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-veno - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-westwood - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tcp-yeah - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda10021 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda10023 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda10048 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda1004x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda10071 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda10086 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda18212 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda18218 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda18271 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda18271c2dd - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda665x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda8083 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda8261 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda826x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda827x - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda8290 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tda9887 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tea5761 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tea5767 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-test-power - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-thmc50 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ti-hecc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tmp102 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tmp401 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tmp421 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tsc2005 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tsc2007 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tsc40 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tsl2550 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tua6100 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tun - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tuner - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tuner-simple - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tuner-types - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tuner-xc2028 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tunnel4 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tunnel6 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-tveeprom - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-twl4030-vibra - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-twl6040-vibra - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-udf - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-udlfb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-uinput - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-uio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-uio-pdrv - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-uio-pdrv-genirq - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-uio-pruss - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usb-debug - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usb-wwan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usb8xxx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usblcd - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usbled - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usbnet - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usbserial - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usbtest - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usbtmc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usbtouchscreen - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-usbvision - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-uvcvideo - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-vcan - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ves1820 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-ves1x93 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-videobuf-core - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-videobuf-dvb - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-videobuf-vmalloc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-videobuf2-core - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-videobuf2-memops - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-videobuf2-vmalloc - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-virtio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-virtio-mmio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-virtio-ring - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-visor - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-vivi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-vivopay-serial - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-vt1211 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w1-bq27000 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w1-ds2408 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w1-ds2423 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w1-ds2431 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w1-ds2433 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w1-ds2760 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w1-ds2780 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w1-smem - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w35und - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w83627ehf - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w83627hf - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w83781d - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w83791d - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w83792d - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w83793 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w83795 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w83l785ts - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-w83l786ng - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-wimax - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-wl12xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-wl12xx-sdio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-wl12xx-spi - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-wm8775 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-x-tables - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xc4000 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xc5000 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xfrm-ipcomp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xfrm4-tunnel - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xfrm6-mode-beet - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xfrm6-mode-ro - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xfrm6-mode-transport - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xfrm6-mode-tunnel - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xfrm6-tunnel - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xfs - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xor - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xt-audit - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-xt-tcpudp - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-yealink - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-zaurus - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-zd1201 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-zd1211rw - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-zio - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-zl10036 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-zl10039 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-zl10353 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-zl6100 - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-module-zr364xx - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
kernel-modules - 3.2.18-r12j+gitr720e07b4c1f687b61b147b31c698cb6816d72f01
lcms - 1.17-r4
led-config - 1.0-r12
liba52-0 - 0.7.4-r4
libacl1 - 2.2.51-r3
libasound2 - 1.0.25-r1
libaspell15 - 0.60.6.1-r1
libass4 - 0.9.11-r1.0
libatasmart4 - 0.17-r1
libatk-1.0-0 - 2.2.0-r2
libatk-1.0-dev - 2.2.0-r2
libattr-dev - 2.4.46-r4
libattr1 - 2.4.46-r4
libavahi-client3 - 0.6.31-r2.0
libavahi-common3 - 0.6.31-r2.0
libavahi-core7 - 0.6.31-r2.0
libavahi-glib1 - 0.6.31-r2.0
libavahi-gobject0 - 0.6.31-r2.0
libavahi-ui0 - 0.6.31-r2.0
libavcodec53 - 0.7.4-r5.0
libavfilter2 - 0.7.4-r5.0
libavformat53 - 0.7.4-r5.0
libavutil51 - 0.7.4-r5.0
libbabl-0.1-0 - 0.1.6-r0
libblkid-dev - 2.21-r5
libblkid1 - 2.21-r5
libbz2-0 - 1.0.6-r5
libbz2-dev - 1.0.6-r5
libc6 - 2.12-r28
libc6-dev - 2.12-r28
libcairo-dev - 1.10.2-r6
libcairo-gobject2 - 1.10.2-r6
libcairo-perf-utils - 1.10.2-r6
libcairo-script-interpreter2 - 1.10.2-r6
libcairo2 - 1.10.2-r6
libcairomm-1.0-1 - 1.10.0-r1
libcanberra-gtk - 0.26-r1
libcanberra0 - 0.26-r1
libcap-dev - 2.22-r3
libcap2 - 2.22-r3
libcec - 1.4.0-r1
libcidn1 - 2.12-r28
libcom-err2 - 1.42.1-r0
libcrypto1.0.0 - 1.0.0i-r0.2
libcurl-dev - 7.24.0-r0
libcurl5 - 7.24.0-r0
libdaemon0 - 0.14-r0
libdbus-1-3 - 1.4.16-r3.0
libdbus-glib-1-2 - 0.98-r0
libdvdread4 - 4.1.3-10-r0
libe2p2 - 1.42.1-r0
liberation-fonts - 1:1.04-r2
libevent - 2.0.16-r1
libexif12 - 0.6.20-r0
libexpat-dev - 2.0.1-r1
libexpat1 - 2.0.1-r1
libfaad2 - 2.7-r1
libffi-dev - 3.0.10-r0
libffi5 - 3.0.10-r0
libfontconfig-dev - 2.8.0-r4
libfontconfig1 - 2.8.0-r4
libfontenc1 - 1:1.1.1-r0
libform5 - 5.9-r9.1
libformw5 - 5.9-r9.1
libfreetype-dev - 2.4.9-r0
libfreetype6 - 2.4.9-r0
libfribidi0 - 0.19.2-r1
libfuse2 - 2.8.6-r1
libgcc-s-dev - 4.5-r49+svnr184907
libgcc1 - 4.5-r49+svnr184907
libgcrypt-dev - 1.5.0-r0
libgcrypt11 - 1.5.0-r0
libgdbm-compat4 - 1.10-r3
libgdbm-dev - 1.10-r3
libgdbm4 - 1.10-r3
libglade-2.0-0 - 2.6.4-r3
libgles-omap3 - 4.05.00.03-r31
libgles-omap3-blitwsegl - 4.05.00.03-r31
libgles-omap3-blitwsegl-es3 - 4.05.00.03-r31
libgles-omap3-blitwsegl-es5 - 4.05.00.03-r31
libgles-omap3-blitwsegl-es6 - 4.05.00.03-r31
libgles-omap3-blitwsegl-es8 - 4.05.00.03-r31
libgles-omap3-es3 - 4.05.00.03-r31
libgles-omap3-es5 - 4.05.00.03-r31
libgles-omap3-es6 - 4.05.00.03-r31
libgles-omap3-es8 - 4.05.00.03-r31
libgles-omap3-flipwsegl - 4.05.00.03-r31
libgles-omap3-flipwsegl-es3 - 4.05.00.03-r31
libgles-omap3-flipwsegl-es5 - 4.05.00.03-r31
libgles-omap3-flipwsegl-es6 - 4.05.00.03-r31
libgles-omap3-flipwsegl-es8 - 4.05.00.03-r31
libgles-omap3-frontwsegl - 4.05.00.03-r31
libgles-omap3-frontwsegl-es3 - 4.05.00.03-r31
libgles-omap3-frontwsegl-es5 - 4.05.00.03-r31
libgles-omap3-frontwsegl-es6 - 4.05.00.03-r31
libgles-omap3-frontwsegl-es8 - 4.05.00.03-r31
libgles-omap3-linuxfbwsegl - 4.05.00.03-r31
libgles-omap3-linuxfbwsegl-es3 - 4.05.00.03-r31
libgles-omap3-linuxfbwsegl-es5 - 4.05.00.03-r31
libgles-omap3-linuxfbwsegl-es6 - 4.05.00.03-r31
libgles-omap3-linuxfbwsegl-es8 - 4.05.00.03-r31
libgles-omap3-x11demos - 4.05.00.03-r31
libgles-omap3-x11wsegl - 4.05.00.03-r31
libgles-omap3-x11wsegl-es3 - 4.05.00.03-r31
libgles-omap3-x11wsegl-es5 - 4.05.00.03-r31
libgles-omap3-x11wsegl-es6 - 4.05.00.03-r31
libgles-omap3-x11wsegl-es8 - 4.05.00.03-r31
libglib-2.0-0 - 1:2.30.3-r1
libglib-2.0-dev - 1:2.30.3-r1
libglib-2.0-utils - 1:2.30.3-r1
libgmp-dev - 5.0.4-r0
libgmp10 - 5.0.4-r0
libgmpxx4 - 5.0.4-r0
libgnome-desktop-2-17 - 2.32.1-r4
libgnome-keyring0 - 2.32.0-r0
libgnome-menu2 - 2.30.5-r0
libgnomekbd - 2.32.0-r0
libgnutls-dev - 2.12.17-r6.0
libgnutls-extra26 - 2.12.17-r6.0
libgnutls-openssl27 - 2.12.17-r6.0
libgnutls26 - 2.12.17-r6.0
libgnutlsxx27 - 2.12.17-r6.0
libgpg-error-dev - 1.10-r1
libgpg-error0 - 1.10-r1
libgphoto2-2 - 2.4.11-r2
libgphoto2-camlibs - 2.4.11-r2
libgphoto2-port0 - 2.4.11-r2
libgsf - 1.14.21-r3
libgstapp-0.10-0 - 0.10.36-r3
libgstaudio-0.10-0 - 0.10.36-r3
libgstcdda-0.10-0 - 0.10.36-r3
libgstfft-0.10-0 - 0.10.36-r3
libgstinterfaces-0.10-0 - 0.10.36-r3
libgstnetbuffer-0.10-0 - 0.10.36-r3
libgstpbutils-0.10-0 - 0.10.36-r3
libgstriff-0.10-0 - 0.10.36-r3
libgstrtp-0.10-0 - 0.10.36-r3
libgstrtsp-0.10-0 - 0.10.36-r3
libgstsdp-0.10-0 - 0.10.36-r3
libgsttag-0.10-0 - 0.10.36-r3
libgstvideo-0.10-0 - 0.10.36-r3
libgtk-2.0 - 2.24.8-r4
libgtksourceview-2.0-0 - 2.10.5-r0
libgtop-2.0-7 - 2.28.2-r0
libgudev-1.0-0 - 182-r0
libgweather1 - 2.30.3-r0
libical - 0.48-r0
libice-dev - 1:1.0.8-r0
libice6 - 1:1.0.8-r0
libicudata36 - 3.6-r7
libicui18n36 - 3.6-r7
libicuuc36 - 3.6-r7
libjasper-dev - 1.900.1-r1
libjasper1 - 1.900.1-r1
libjavascriptcoregtk-1.0-0 - 1.7.2+svnr101488-r5
libjpeg-dev - 8c+1.2.0-r0
libjpeg8 - 8c+1.2.0-r0
libjson0 - 0.9-r0
libkmod2 - 7-r3
libltdl-dev - 2.4.2-r2.0
libltdl7 - 2.4.2-r2.0
liblzma-dev - 5.0.3-r1
liblzma5 - 5.0.3-r1
liblzo2-2 - 2.06-r1
liblzo2-dev - 2.06-r1
libmad0 - 0.15.1b-r0
libmediactl0 - 0.0.1-r1
libmenu5 - 5.9-r9.1
libmenuw5 - 5.9-r9.1
libmicrohttpd5 - 0.4.6-r0
libmpc2 - 0.8.2-r0
libmpfr4 - 3.1.0-r1
libmysqlclient16 - 5.1.40-r7
libncurses5 - 5.9-r9.1
libncursesw5 - 5.9-r9.1
libnl-3-200 - 3.2.3-r0
libnl-genl-3-200 - 3.2.3-r0
libnotify - 0.6.0-r0
libnss-mdns - 0.10-r4
libogg0 - 1.3.0-r0
libopencv-calib3d-dev - 2.3.1-r3
libopencv-calib3d2.3 - 2.3.1-r3
libopencv-contrib-dev - 2.3.1-r3
libopencv-contrib2.3 - 2.3.1-r3
libopencv-core-dev - 2.3.1-r3
libopencv-core2.3 - 2.3.1-r3
libopencv-features2d-dev - 2.3.1-r3
libopencv-features2d2.3 - 2.3.1-r3
libopencv-flann-dev - 2.3.1-r3
libopencv-flann2.3 - 2.3.1-r3
libopencv-gpu-dev - 2.3.1-r3
libopencv-gpu2.3 - 2.3.1-r3
libopencv-highgui-dev - 2.3.1-r3
libopencv-highgui2.3 - 2.3.1-r3
libopencv-imgproc-dev - 2.3.1-r3
libopencv-imgproc2.3 - 2.3.1-r3
libopencv-legacy-dev - 2.3.1-r3
libopencv-legacy2.3 - 2.3.1-r3
libopencv-ml-dev - 2.3.1-r3
libopencv-ml2.3 - 2.3.1-r3
libopencv-objdetect-dev - 2.3.1-r3
libopencv-objdetect2.3 - 2.3.1-r3
libopencv-ts-dev - 2.3.1-r3
libopencv-ts2.3 - 2.3.1-r3
libopencv-video-dev - 2.3.1-r3
libopencv-video2.3 - 2.3.1-r3
libopenobex1 - 1.5-r0
libopkg1 - 1:0.1.8+svnr633-r9.0
liborc-0.4-0 - 0.4.14-r0.0
libpam - 1.1.5-r3
libpam-dev - 1.1.5-r3
libpam-runtime - 1.1.5-r3
libpanel-applet-3-0 - 2.32.1-r6
libpanel5 - 5.9-r9.1
libpanelw5 - 5.9-r9.1
libpangomm-1.4-1 - 2.28.2-r1
libpciaccess0 - 0.12.902-r0
libpcre0 - 8.21-r1
libpcrecpp0 - 8.21-r1
libperl5 - 5.14.2-r6
libpixman-1-0 - 1:0.25.2-r9
libpixman-1-dev - 1:0.25.2-r9
libpng-dev - 1.2.49-r0
libpng12-0 - 1.2.49-r0
libpng3 - 1.2.49-r0
libpolkit-gtk-1-0 - 0.102-r1
libpoppler-glib8 - 0.18.0-r3
libpoppler18 - 0.18.0-r3
libpopt-dev - 1.16-r0
libpopt0 - 1.16-r0
libpostproc52 - 0.7.4-r5.0
libproxy - 0.4.7-r4
libpthread-stubs-dev - 0.3-r0
libpulse-mainloop-glib0 - 1.1-r8
libpulse0 - 1.1-r8
libpulsecommon - 1.1-r8
libpython2.7-1.0 - 2.7.2-r3.17
libreadline-dev - 6.2-r2
libreadline6 - 6.2-r2
librsvg-2-2 - 2.32.1-r5
librsvg-2-gtk - 2.32.1-r5
libsamplerate0 - 0.1.8-r0
libsdl-1.2-0 - 1.2.15-r0
libsdl-mixer-1.2-0 - 1.2.11-r0
libsigc-2.0-0 - 2.2.9-r0
libsm-dev - 1:1.2.1-r0
libsm6 - 1:1.2.1-r0
libsmbclient0 - 3.5.6-r1
libsndfile1 - 1.0.25-r0
libsocketcan2 - 0.0.8-r0
libsoup-2.4 - 2.37.2-r1
libsqlite3-0 - 3.7.10-r2
libsqlite3-dev - 3.7.10-r2
libss2 - 1.42.1-r0
libssl1.0.0 - 1.0.0i-r0.2
libstartup-notification-1-0 - 0.12-r1
libstdc++-dev - 4.5-r49+svnr184907
libstdc++6 - 4.5-r49+svnr184907
libswscale2 - 0.7.4-r5.0
libsysfs2 - 2.1.0-r3
libsystemd-daemon0 - v44-45-g3eff420-r27
libsystemd-id128-0 - v44-45-g3eff420-r27
libsystemd-journal0 - v44-45-g3eff420-r27
libsystemd-login0 - v44-45-g3eff420-r27
libtalloc2 - 2.0.1-r1
libtasn1-3 - 2.11-r0
libtasn1-dev - 2.11-r0
libtheora - 1.1.1-r1
libthread-db1 - 2.12-r28
libtic5 - 5.9-r9.1
libticw5 - 5.9-r9.1
libtiff-dev - 4.0.1-r1
libtiff5 - 4.0.1-r1
libtinfo5 - 5.9-r9.1
libtool - 2.4.2-r2.0
libtool-dev - 2.4.2-r2.0
libts-1.0-0 - 1.0+gitr1+e17263ef401ee885a27d649b90b577cfb44500e0-r8
libudev0 - 182-r0
libunique-1.0-0 - 1.1.6-r6
libusb-0.1-4 - 1:0.1.3-r4
libusb-1.0-0 - 1.0.8-r4
libuuid-dev - 2.21-r5
libuuid1 - 2.21-r5
libv4l2subdev0 - 0.0.1-r1
libvorbis - 1.3.3-r0
libvorbisidec1 - 20120314-r0
libvte9 - 0.28.2-r3
libwebkitgtk-1.0-0 - 1.7.2+svnr101488-r5
libwnck - 2.30.5-r1
libwrap0 - 7.6-r9
libx11-6 - 1:1.4.4-r3
libx11-dev - 1:1.4.4-r3
libx11-xcb1 - 1:1.4.4-r3
libxau-dev - 1:1.0.7-r0
libxau6 - 1:1.0.7-r0
libxaw7-7 - 1:1.0.10-r0
libxcb-composite0 - 1.8.1-r0
libxcb-damage0 - 1.8.1-r0
libxcb-dev - 1.8.1-r0
libxcb-dpms0 - 1.8.1-r0
libxcb-dri2-0 - 1.8.1-r0
libxcb-glx0 - 1.8.1-r0
libxcb-randr0 - 1.8.1-r0
libxcb-record0 - 1.8.1-r0
libxcb-render0 - 1.8.1-r0
libxcb-res0 - 1.8.1-r0
libxcb-screensaver0 - 1.8.1-r0
libxcb-shape0 - 1.8.1-r0
libxcb-shm0 - 1.8.1-r0
libxcb-sync0 - 1.8.1-r0
libxcb-util0 - 0.3.8-r0
libxcb-xevie0 - 1.8.1-r0
libxcb-xf86dri0 - 1.8.1-r0
libxcb-xfixes0 - 1.8.1-r0
libxcb-xinerama0 - 1.8.1-r0
libxcb-xprint0 - 1.8.1-r0
libxcb-xtest0 - 1.8.1-r0
libxcb-xv0 - 1.8.1-r0
libxcb-xvmc0 - 1.8.1-r0
libxcb1 - 1.8.1-r0
libxcomposite-dev - 1:0.4.3-r0
libxcomposite1 - 1:0.4.3-r0
libxcursor-dev - 1:1.1.13-r0
libxcursor1 - 1:1.1.13-r0
libxdamage-dev - 1:1.1.3-r1
libxdamage1 - 1:1.1.3-r1
libxdmcp-dev - 1:1.1.1-r0
libxdmcp6 - 1:1.1.1-r0
libxext-dev - 1:1.3.1-r0
libxext6 - 1:1.3.1-r0
libxfixes-dev - 1:5.0-r0
libxfixes3 - 1:5.0-r0
libxfont1 - 1:1.4.5-r0
libxfontcache1 - 1:1.0.5-r1
libxft-dev - 1:2.3.0-r0
libxft2 - 1:2.3.0-r0
libxi6 - 1:1.4.5-r0
libxkbfile1 - 1:1.0.8-r0
libxklavier16 - 5.0-r0
libxml-parser-perl - 2.41-r2
libxml2 - 2.7.8-r7
libxml2-dev - 2.7.8-r7
libxmu6 - 1:1.1.1-r0
libxmuu1 - 1:1.1.1-r0
libxpm4 - 1:3.5.10-r0
libxrandr-dev - 1:1.3.2-r0
libxrandr2 - 1:1.3.2-r0
libxrender-dev - 1:0.9.7-r0
libxrender1 - 1:0.9.7-r0
libxslt - 1.1.26-r7
libxss1 - 1:1.2.2-r0
libxt6 - 1:1.1.2-r0
libxtst6 - 1:1.2.1-r0
libxv1 - 1.0.7-r0
libxxf86dga1 - 1:1.1.3-r2
libxxf86misc1 - 1:1.0.3-r0
libz-dev - 1.2.6-r1
libz1 - 1.2.6-r1
linux-libc-headers-dev - 3.2-r1
lmbench - 3.0-a9-r0
locale-base-en-us - 2.12-r20
ltp-ddt - 0.0.4-r1
m4 - 1.4.16-r2
make - 3.82-r2
matchbox-terminal - 0.0+git1+3fc25cb811a8ed306de897edf9b930f4402f3852-r0
media-ctl - 0.0.1-r1
memtester - 4.1.3-r0
metacity - 2.30.3-r3
midori - 0.4.4-r1
mime-support - 3.48-r0
minicom - 2.6.1-r0
mkfontdir - 1:1.0.7-r0
mkfontscale - 1.1.0-r0
module-init-tools - 3.16-r0
module-init-tools-depmod - 3.16-r0
mplayer-common - 0.0.1-r1
mplayer2 - 2.0+gitr1+e3f5043233336d8b4b0731c6a8b42a8fda5535ac-r11
nano - 2.2.5-r2.0
nautilus - 2.32.2-r6
ncurses - 5.9-r9.1
ncurses-dev - 5.9-r9.1
ncurses-terminfo - 5.9-r9.1
ncurses-terminfo-base - 5.9-r9.1
netbase - 4.47-r2
nodejs - 0.6.18-r0
nodejs-dev - 0.6.18-r0
nodejs4 - 0.4.12-r0
ntpdate - 4.2.6p3-r5
obex-data-server - 0.4.6-r0
obexd - 0.44-r1
ocf-linux - 20100325-r3.0
ocf-linux-dev - 20100325-r3.0
ofono - 1.5-r1
omap3-sgx-modules - 4.05.00.03-r12b
opencv - 2.3.1-r3
opencv-dev - 2.3.1-r3
openssh-misc - 5.9p1-r5
openssh-sftp - 5.9p1-r5
openssh-sftp-server - 5.9p1-r5
openssh-ssh - 5.9p1-r5
openssl - 1.0.0i-r0.2
openssl-dev - 1.0.0i-r0.2
opkg - 1:0.1.8+svnr633-r9.0
opkg-config-base - 1.0-r1
pam-plugin-access - 1.1.5-r3
pam-plugin-ck-connector - 0.4.5-r9
pam-plugin-deny - 1.1.5-r3
pam-plugin-env - 1.1.5-r3
pam-plugin-faildelay - 1.1.5-r3
pam-plugin-group - 1.1.5-r3
pam-plugin-lastlog - 1.1.5-r3
pam-plugin-limits - 1.1.5-r3
pam-plugin-loginuid - 1.1.5-r3
pam-plugin-mail - 1.1.5-r3
pam-plugin-motd - 1.1.5-r3
pam-plugin-nologin - 1.1.5-r3
pam-plugin-permit - 1.1.5-r3
pam-plugin-rootok - 1.1.5-r3
pam-plugin-securetty - 1.1.5-r3
pam-plugin-shells - 1.1.5-r3
pam-plugin-unix - 1.1.5-r3
pam-plugin-warn - 1.1.5-r3
pango - 1.29.4-r4
pango-dev - 1.29.4-r4
pango-module-basic-fc - 1.29.4-r4
pango-module-basic-x - 1.29.4-r4
patch - 2.6.1-r0
perl - 5.14.2-r6
perl-module-abbrev - 5.14.2-r6
perl-module-anydbm-file - 5.14.2-r6
perl-module-app-cpan - 5.14.2-r6
perl-module-app-prove - 5.14.2-r6
perl-module-app-prove-state - 5.14.2-r6
perl-module-app-prove-state-result - 5.14.2-r6
perl-module-app-prove-state-result-test - 5.14.2-r6
perl-module-archive-extract - 5.14.2-r6
perl-module-archive-tar - 5.14.2-r6
perl-module-archive-tar-constant - 5.14.2-r6
perl-module-archive-tar-file - 5.14.2-r6
perl-module-assert - 5.14.2-r6
perl-module-attribute-handlers - 5.14.2-r6
perl-module-attributes - 5.14.2-r6
perl-module-autodie - 5.14.2-r6
perl-module-autodie-exception - 5.14.2-r6
perl-module-autodie-exception-system - 5.14.2-r6
perl-module-autodie-hints - 5.14.2-r6
perl-module-autoloader - 5.14.2-r6
perl-module-autosplit - 5.14.2-r6
perl-module-autouse - 5.14.2-r6
perl-module-b - 5.14.2-r6
perl-module-b-concise - 5.14.2-r6
perl-module-b-debug - 5.14.2-r6
perl-module-b-deparse - 5.14.2-r6
perl-module-b-lint - 5.14.2-r6
perl-module-b-lint-debug - 5.14.2-r6
perl-module-b-showlex - 5.14.2-r6
perl-module-b-terse - 5.14.2-r6
perl-module-b-xref - 5.14.2-r6
perl-module-base - 5.14.2-r6
perl-module-benchmark - 5.14.2-r6
perl-module-bigfloat - 5.14.2-r6
perl-module-bigint - 5.14.2-r6
perl-module-bignum - 5.14.2-r6
perl-module-bigrat - 5.14.2-r6
perl-module-blib - 5.14.2-r6
perl-module-build - 5.14.2-r6
perl-module-build.pm - 5.14.2-r6
perl-module-bytes - 5.14.2-r6
perl-module-bytes-heavy - 5.14.2-r6
perl-module-cacheout - 5.14.2-r6
perl-module-carp - 5.14.2-r6
perl-module-carp-heavy - 5.14.2-r6
perl-module-cgi - 5.14.2-r6
perl-module-cgi-apache - 5.14.2-r6
perl-module-cgi-carp - 5.14.2-r6
perl-module-cgi-cookie - 5.14.2-r6
perl-module-cgi-fast - 5.14.2-r6
perl-module-cgi-pretty - 5.14.2-r6
perl-module-cgi-push - 5.14.2-r6
perl-module-cgi-switch - 5.14.2-r6
perl-module-cgi-util - 5.14.2-r6
perl-module-charnames - 5.14.2-r6
perl-module-class-struct - 5.14.2-r6
perl-module-complete - 5.14.2-r6
perl-module-compress - 5.14.2-r6
perl-module-compress-raw-bzip2 - 5.14.2-r6
perl-module-compress-raw-zlib - 5.14.2-r6
perl-module-compress-zlib - 5.14.2-r6
perl-module-config - 5.14.2-r6
perl-module-config-extensions - 5.14.2-r6
perl-module-config-git - 5.14.2-r6
perl-module-constant - 5.14.2-r6
perl-module-corelist.pm - 5.14.2-r6
perl-module-cpan - 5.14.2-r6
perl-module-cpanplus - 5.14.2-r6
perl-module-ctime - 5.14.2-r6
perl-module-cwd - 5.14.2-r6
perl-module-data - 5.14.2-r6
perl-module-data-dumper - 5.14.2-r6
perl-module-db - 5.14.2-r6
perl-module-dbm-filter - 5.14.2-r6
perl-module-dbm-filter-compress - 5.14.2-r6
perl-module-dbm-filter-encode - 5.14.2-r6
perl-module-dbm-filter-int32 - 5.14.2-r6
perl-module-dbm-filter-null - 5.14.2-r6
perl-module-dbm-filter-utf8 - 5.14.2-r6
perl-module-deprecate - 5.14.2-r6
perl-module-devel - 5.14.2-r6
perl-module-devel-dprof - 5.14.2-r6
perl-module-devel-innerpackage - 5.14.2-r6
perl-module-devel-peek - 5.14.2-r6
perl-module-devel-ppport - 5.14.2-r6
perl-module-devel-selfstubber - 5.14.2-r6
perl-module-diagnostics - 5.14.2-r6
perl-module-digest - 5.14.2-r6
perl-module-digest-base - 5.14.2-r6
perl-module-digest-file - 5.14.2-r6
perl-module-digest-md5 - 5.14.2-r6
perl-module-digest-sha - 5.14.2-r6
perl-module-dirhandle - 5.14.2-r6
perl-module-dotsh - 5.14.2-r6
perl-module-dumpvar - 5.14.2-r6
perl-module-dynaloader - 5.14.2-r6
perl-module-encode - 5.14.2-r6
perl-module-encode--pm - 5.14.2-r6
perl-module-encode--t - 5.14.2-r6
perl-module-encode-alias - 5.14.2-r6
perl-module-encode-byte - 5.14.2-r6
perl-module-encode-changes - 5.14.2-r6
perl-module-encode-cjkconstants - 5.14.2-r6
perl-module-encode-cn - 5.14.2-r6
perl-module-encode-cn-hz - 5.14.2-r6
perl-module-encode-config - 5.14.2-r6
perl-module-encode-configlocal-pm - 5.14.2-r6
perl-module-encode-ebcdic - 5.14.2-r6
perl-module-encode-encoder - 5.14.2-r6
perl-module-encode-encoding - 5.14.2-r6
perl-module-encode-gsm0338 - 5.14.2-r6
perl-module-encode-guess - 5.14.2-r6
perl-module-encode-jp - 5.14.2-r6
perl-module-encode-jp-h2z - 5.14.2-r6
perl-module-encode-jp-jis7 - 5.14.2-r6
perl-module-encode-kr - 5.14.2-r6
perl-module-encode-kr-2022-kr - 5.14.2-r6
perl-module-encode-makefile-pl - 5.14.2-r6
perl-module-encode-mime-header - 5.14.2-r6
perl-module-encode-mime-header-iso-2022-jp - 5.14.2-r6
perl-module-encode-mime-name - 5.14.2-r6
perl-module-encode-readme - 5.14.2-r6
perl-module-encode-symbol - 5.14.2-r6
perl-module-encode-tw - 5.14.2-r6
perl-module-encode-unicode - 5.14.2-r6
perl-module-encode-unicode-utf7 - 5.14.2-r6
perl-module-encoding - 5.14.2-r6
perl-module-encoding-warnings - 5.14.2-r6
perl-module-english - 5.14.2-r6
perl-module-errno - 5.14.2-r6
perl-module-exceptions - 5.14.2-r6
perl-module-exporter - 5.14.2-r6
perl-module-exporter-heavy - 5.14.2-r6
perl-module-extutils-cbuilder - 5.14.2-r6
perl-module-extutils-cbuilder-base - 5.14.2-r6
perl-module-extutils-cbuilder-platform-aix - 5.14.2-r6
perl-module-extutils-cbuilder-platform-cygwin - 5.14.2-r6
perl-module-extutils-cbuilder-platform-darwin - 5.14.2-r6
perl-module-extutils-cbuilder-platform-dec-osf - 5.14.2-r6
perl-module-extutils-cbuilder-platform-os2 - 5.14.2-r6
perl-module-extutils-cbuilder-platform-unix - 5.14.2-r6
perl-module-extutils-cbuilder-platform-vms - 5.14.2-r6
perl-module-extutils-cbuilder-platform-windows - 5.14.2-r6
perl-module-extutils-cbuilder-platform-windows-bcc - 5.14.2-r6
perl-module-extutils-cbuilder-platform-windows-gcc - 5.14.2-r6
perl-module-extutils-cbuilder-platform-windows-msvc - 5.14.2-r6
perl-module-extutils-command - 5.14.2-r6
perl-module-extutils-command-mm - 5.14.2-r6
perl-module-extutils-constant - 5.14.2-r6
perl-module-extutils-constant-base - 5.14.2-r6
perl-module-extutils-constant-proxysubs - 5.14.2-r6
perl-module-extutils-constant-utils - 5.14.2-r6
perl-module-extutils-constant-xs - 5.14.2-r6
perl-module-extutils-embed - 5.14.2-r6
perl-module-extutils-install - 5.14.2-r6
perl-module-extutils-installed - 5.14.2-r6
perl-module-extutils-liblist - 5.14.2-r6
perl-module-extutils-liblist-kid - 5.14.2-r6
perl-module-extutils-makemaker - 5.14.2-r6
perl-module-extutils-makemaker-config - 5.14.2-r6
perl-module-extutils-makemaker-yaml - 5.14.2-r6
perl-module-extutils-manifest - 5.14.2-r6
perl-module-extutils-miniperl - 5.14.2-r6
perl-module-extutils-mkbootstrap - 5.14.2-r6
perl-module-extutils-mksymlists - 5.14.2-r6
perl-module-extutils-mm - 5.14.2-r6
perl-module-extutils-mm-aix - 5.14.2-r6
perl-module-extutils-mm-any - 5.14.2-r6
perl-module-extutils-mm-beos - 5.14.2-r6
perl-module-extutils-mm-cygwin - 5.14.2-r6
perl-module-extutils-mm-darwin - 5.14.2-r6
perl-module-extutils-mm-dos - 5.14.2-r6
perl-module-extutils-mm-macos - 5.14.2-r6
perl-module-extutils-mm-nw5 - 5.14.2-r6
perl-module-extutils-mm-os2 - 5.14.2-r6
perl-module-extutils-mm-qnx - 5.14.2-r6
perl-module-extutils-mm-unix - 5.14.2-r6
perl-module-extutils-mm-uwin - 5.14.2-r6
perl-module-extutils-mm-vms - 5.14.2-r6
perl-module-extutils-mm-vos - 5.14.2-r6
perl-module-extutils-mm-win32 - 5.14.2-r6
perl-module-extutils-mm-win95 - 5.14.2-r6
perl-module-extutils-my - 5.14.2-r6
perl-module-extutils-packlist - 5.14.2-r6
perl-module-extutils-parsexs - 5.14.2-r6
perl-module-extutils-testlib - 5.14.2-r6
perl-module-fastcwd - 5.14.2-r6
perl-module-fatal - 5.14.2-r6
perl-module-fcntl - 5.14.2-r6
perl-module-feature - 5.14.2-r6
perl-module-fields - 5.14.2-r6
perl-module-file - 5.14.2-r6
perl-module-file-basename - 5.14.2-r6
perl-module-file-compare - 5.14.2-r6
perl-module-file-copy - 5.14.2-r6
perl-module-file-dosglob - 5.14.2-r6
perl-module-file-fetch - 5.14.2-r6
perl-module-file-find - 5.14.2-r6
perl-module-file-glob - 5.14.2-r6
perl-module-file-globmapper - 5.14.2-r6
perl-module-file-path - 5.14.2-r6
perl-module-file-spec - 5.14.2-r6
perl-module-file-spec-cygwin - 5.14.2-r6
perl-module-file-spec-epoc - 5.14.2-r6
perl-module-file-spec-functions - 5.14.2-r6
perl-module-file-spec-mac - 5.14.2-r6
perl-module-file-spec-os2 - 5.14.2-r6
perl-module-file-spec-unix - 5.14.2-r6
perl-module-file-spec-vms - 5.14.2-r6
perl-module-file-spec-win32 - 5.14.2-r6
perl-module-file-stat - 5.14.2-r6
perl-module-file-temp - 5.14.2-r6
perl-module-filecache - 5.14.2-r6
perl-module-filehandle - 5.14.2-r6
perl-module-filetest - 5.14.2-r6
perl-module-filter - 5.14.2-r6
perl-module-filter-simple - 5.14.2-r6
perl-module-filter-util-call - 5.14.2-r6
perl-module-find - 5.14.2-r6
perl-module-findbin - 5.14.2-r6
perl-module-finddepth - 5.14.2-r6
perl-module-flush - 5.14.2-r6
perl-module-gdbm-file - 5.14.2-r6
perl-module-getcwd - 5.14.2-r6
perl-module-getopt - 5.14.2-r6
perl-module-getopt-long - 5.14.2-r6
perl-module-getopt-std - 5.14.2-r6
perl-module-getopts - 5.14.2-r6
perl-module-hash - 5.14.2-r6
perl-module-hash-util - 5.14.2-r6
perl-module-hash-util-fieldhash - 5.14.2-r6
perl-module-hostname - 5.14.2-r6
perl-module-i18n - 5.14.2-r6
perl-module-i18n-langinfo - 5.14.2-r6
perl-module-i18n-langtags - 5.14.2-r6
perl-module-i18n-langtags-detect - 5.14.2-r6
perl-module-i18n-langtags-list - 5.14.2-r6
perl-module-if - 5.14.2-r6
perl-module-importenv - 5.14.2-r6
perl-module-inc-latest - 5.14.2-r6
perl-module-inc-latest-private - 5.14.2-r6
perl-module-integer - 5.14.2-r6
perl-module-io - 5.14.2-r6
perl-module-io-compress-adapter-bzip2 - 5.14.2-r6
perl-module-io-compress-adapter-deflate - 5.14.2-r6
perl-module-io-compress-adapter-identity - 5.14.2-r6
perl-module-io-compress-base - 5.14.2-r6
perl-module-io-compress-base-common - 5.14.2-r6
perl-module-io-compress-bzip2 - 5.14.2-r6
perl-module-io-compress-deflate - 5.14.2-r6
perl-module-io-compress-gzip - 5.14.2-r6
perl-module-io-compress-gzip-constants - 5.14.2-r6
perl-module-io-compress-rawdeflate - 5.14.2-r6
perl-module-io-compress-zip - 5.14.2-r6
perl-module-io-compress-zip-constants - 5.14.2-r6
perl-module-io-compress-zlib-constants - 5.14.2-r6
perl-module-io-compress-zlib-extra - 5.14.2-r6
perl-module-io-dir - 5.14.2-r6
perl-module-io-file - 5.14.2-r6
perl-module-io-handle - 5.14.2-r6
perl-module-io-pipe - 5.14.2-r6
perl-module-io-poll - 5.14.2-r6
perl-module-io-seekable - 5.14.2-r6
perl-module-io-select - 5.14.2-r6
perl-module-io-socket - 5.14.2-r6
perl-module-io-socket-inet - 5.14.2-r6
perl-module-io-socket-unix - 5.14.2-r6
perl-module-io-uncompress-adapter-bunzip2 - 5.14.2-r6
perl-module-io-uncompress-adapter-identity - 5.14.2-r6
perl-module-io-uncompress-adapter-inflate - 5.14.2-r6
perl-module-io-uncompress-anyinflate - 5.14.2-r6
perl-module-io-uncompress-anyuncompress - 5.14.2-r6
perl-module-io-uncompress-base - 5.14.2-r6
perl-module-io-uncompress-bunzip2 - 5.14.2-r6
perl-module-io-uncompress-gunzip - 5.14.2-r6
perl-module-io-uncompress-inflate - 5.14.2-r6
perl-module-io-uncompress-rawinflate - 5.14.2-r6
perl-module-io-uncompress-unzip - 5.14.2-r6
perl-module-io-zlib - 5.14.2-r6
perl-module-ipc - 5.14.2-r6
perl-module-ipc-cmd - 5.14.2-r6
perl-module-ipc-msg - 5.14.2-r6
perl-module-ipc-open2 - 5.14.2-r6
perl-module-ipc-open3 - 5.14.2-r6
perl-module-ipc-semaphore - 5.14.2-r6
perl-module-ipc-sharedmem - 5.14.2-r6
perl-module-ipc-sysv - 5.14.2-r6
perl-module-less - 5.14.2-r6
perl-module-lib - 5.14.2-r6
perl-module-list - 5.14.2-r6
perl-module-list-util - 5.14.2-r6
perl-module-list-util-pp - 5.14.2-r6
perl-module-list-util-xs - 5.14.2-r6
perl-module-load - 5.14.2-r6
perl-module-load.pm - 5.14.2-r6
perl-module-loaded.pm - 5.14.2-r6
perl-module-locale - 5.14.2-r6
perl-module-locale-codes - 5.14.2-r6
perl-module-locale-codes-country - 5.14.2-r6
perl-module-locale-codes-currency - 5.14.2-r6
perl-module-locale-codes-language - 5.14.2-r6
perl-module-locale-codes-script - 5.14.2-r6
perl-module-locale-constants - 5.14.2-r6
perl-module-locale-country - 5.14.2-r6
perl-module-locale-currency - 5.14.2-r6
perl-module-locale-language - 5.14.2-r6
perl-module-locale-maketext - 5.14.2-r6
perl-module-locale-maketext-guts - 5.14.2-r6
perl-module-locale-maketext-gutsloader - 5.14.2-r6
perl-module-locale-maketext-simple - 5.14.2-r6
perl-module-locale-script - 5.14.2-r6
perl-module-log-message - 5.14.2-r6
perl-module-log-message-config - 5.14.2-r6
perl-module-log-message-handlers - 5.14.2-r6
perl-module-log-message-item - 5.14.2-r6
perl-module-log-message-simple - 5.14.2-r6
perl-module-look - 5.14.2-r6
perl-module-math - 5.14.2-r6
perl-module-math-bigfloat - 5.14.2-r6
perl-module-math-bigfloat-trace - 5.14.2-r6
perl-module-math-bigint - 5.14.2-r6
perl-module-math-bigint-calc - 5.14.2-r6
perl-module-math-bigint-calcemu - 5.14.2-r6
perl-module-math-bigint-fastcalc - 5.14.2-r6
perl-module-math-bigint-trace - 5.14.2-r6
perl-module-math-bigrat - 5.14.2-r6
perl-module-math-complex - 5.14.2-r6
perl-module-math-trig - 5.14.2-r6
perl-module-memoize - 5.14.2-r6
perl-module-memoize-anydbm-file - 5.14.2-r6
perl-module-memoize-expire - 5.14.2-r6
perl-module-memoize-expirefile - 5.14.2-r6
perl-module-memoize-expiretest - 5.14.2-r6
perl-module-memoize-ndbm-file - 5.14.2-r6
perl-module-memoize-sdbm-file - 5.14.2-r6
perl-module-memoize-storable - 5.14.2-r6
perl-module-mime - 5.14.2-r6
perl-module-mime-base64 - 5.14.2-r6
perl-module-mime-quotedprint - 5.14.2-r6
perl-module-mro - 5.14.2-r6
perl-module-net-cmd - 5.14.2-r6
perl-module-net-config - 5.14.2-r6
perl-module-net-domain - 5.14.2-r6
perl-module-net-ftp - 5.14.2-r6
perl-module-net-ftp-a - 5.14.2-r6
perl-module-net-ftp-dataconn - 5.14.2-r6
perl-module-net-ftp-e - 5.14.2-r6
perl-module-net-ftp-i - 5.14.2-r6
perl-module-net-ftp-l - 5.14.2-r6
perl-module-net-hostent - 5.14.2-r6
perl-module-net-netent - 5.14.2-r6
perl-module-net-netrc - 5.14.2-r6
perl-module-net-nntp - 5.14.2-r6
perl-module-net-ping - 5.14.2-r6
perl-module-net-pop3 - 5.14.2-r6
perl-module-net-protoent - 5.14.2-r6
perl-module-net-servent - 5.14.2-r6
perl-module-net-smtp - 5.14.2-r6
perl-module-net-time - 5.14.2-r6
perl-module-newgetopt - 5.14.2-r6
perl-module-next - 5.14.2-r6
perl-module-o - 5.14.2-r6
perl-module-object-accessor - 5.14.2-r6
perl-module-opcode - 5.14.2-r6
perl-module-open - 5.14.2-r6
perl-module-open2 - 5.14.2-r6
perl-module-open3 - 5.14.2-r6
perl-module-ops - 5.14.2-r6
perl-module-overload - 5.14.2-r6
perl-module-overload-numbers - 5.14.2-r6
perl-module-overloading - 5.14.2-r6
perl-module-package-constants - 5.14.2-r6
perl-module-params-check - 5.14.2-r6
perl-module-parent - 5.14.2-r6
perl-module-parse-cpan-meta - 5.14.2-r6
perl-module-perl5db - 5.14.2-r6
perl-module-perlio - 5.14.2-r6
perl-module-perlio-encoding - 5.14.2-r6
perl-module-perlio-scalar - 5.14.2-r6
perl-module-perlio-via - 5.14.2-r6
perl-module-perlio-via-quotedprint - 5.14.2-r6
perl-module-pluggable - 5.14.2-r6
perl-module-pluggable.pm - 5.14.2-r6
perl-module-pod-checker - 5.14.2-r6
perl-module-pod-escapes - 5.14.2-r6
perl-module-pod-find - 5.14.2-r6
perl-module-pod-functions - 5.14.2-r6
perl-module-pod-inputobjects - 5.14.2-r6
perl-module-pod-latex - 5.14.2-r6
perl-module-pod-man - 5.14.2-r6
perl-module-pod-parselink - 5.14.2-r6
perl-module-pod-parser - 5.14.2-r6
perl-module-pod-parseutils - 5.14.2-r6
perl-module-pod-perldoc - 5.14.2-r6
perl-module-pod-perldoc-baseto - 5.14.2-r6
perl-module-pod-perldoc-getoptsoo - 5.14.2-r6
perl-module-pod-perldoc-tochecker - 5.14.2-r6
perl-module-pod-perldoc-toman - 5.14.2-r6
perl-module-pod-perldoc-tonroff - 5.14.2-r6
perl-module-pod-perldoc-topod - 5.14.2-r6
perl-module-pod-perldoc-tortf - 5.14.2-r6
perl-module-pod-perldoc-totext - 5.14.2-r6
perl-module-pod-perldoc-totk - 5.14.2-r6
perl-module-pod-perldoc-toxml - 5.14.2-r6
perl-module-pod-plaintext - 5.14.2-r6
perl-module-pod-select - 5.14.2-r6
perl-module-pod-simple - 5.14.2-r6
perl-module-pod-simple-blackbox - 5.14.2-r6
perl-module-pod-simple-checker - 5.14.2-r6
perl-module-pod-simple-debug - 5.14.2-r6
perl-module-pod-simple-dumpastext - 5.14.2-r6
perl-module-pod-simple-dumpasxml - 5.14.2-r6
perl-module-pod-simple-html - 5.14.2-r6
perl-module-pod-simple-htmlbatch - 5.14.2-r6
perl-module-pod-simple-htmllegacy - 5.14.2-r6
perl-module-pod-simple-linksection - 5.14.2-r6
perl-module-pod-simple-methody - 5.14.2-r6
perl-module-pod-simple-progress - 5.14.2-r6
perl-module-pod-simple-pullparser - 5.14.2-r6
perl-module-pod-simple-pullparserendtoken - 5.14.2-r6
perl-module-pod-simple-pullparserstarttoken - 5.14.2-r6
perl-module-pod-simple-pullparsertexttoken - 5.14.2-r6
perl-module-pod-simple-pullparsertoken - 5.14.2-r6
perl-module-pod-simple-rtf - 5.14.2-r6
perl-module-pod-simple-search - 5.14.2-r6
perl-module-pod-simple-simpletree - 5.14.2-r6
perl-module-pod-simple-text - 5.14.2-r6
perl-module-pod-simple-textcontent - 5.14.2-r6
perl-module-pod-simple-tiedoutfh - 5.14.2-r6
perl-module-pod-simple-transcode - 5.14.2-r6
perl-module-pod-simple-transcodedumb - 5.14.2-r6
perl-module-pod-simple-transcodesmart - 5.14.2-r6
perl-module-pod-simple-xhtml - 5.14.2-r6
perl-module-pod-simple-xmloutstream - 5.14.2-r6
perl-module-pod-text - 5.14.2-r6
perl-module-pod-text-color - 5.14.2-r6
perl-module-pod-text-overstrike - 5.14.2-r6
perl-module-pod-text-termcap - 5.14.2-r6
perl-module-pod-usage - 5.14.2-r6
perl-module-posix - 5.14.2-r6
perl-module-pwd - 5.14.2-r6
perl-module-re - 5.14.2-r6
perl-module-safe - 5.14.2-r6
perl-module-scalar-util - 5.14.2-r6
perl-module-scalar-util-pp - 5.14.2-r6
perl-module-sdbm - 5.14.2-r6
perl-module-sdbm-file - 5.14.2-r6
perl-module-search-dict - 5.14.2-r6
perl-module-selectsaver - 5.14.2-r6
perl-module-selfloader - 5.14.2-r6
perl-module-shell - 5.14.2-r6
perl-module-shellwords - 5.14.2-r6
perl-module-sigtrap - 5.14.2-r6
perl-module-socket - 5.14.2-r6
perl-module-sort - 5.14.2-r6
perl-module-stat - 5.14.2-r6
perl-module-storable - 5.14.2-r6
perl-module-strict - 5.14.2-r6
perl-module-subs - 5.14.2-r6
perl-module-symbol - 5.14.2-r6
perl-module-sys - 5.14.2-r6
perl-module-sys-hostname - 5.14.2-r6
perl-module-sys-syslog - 5.14.2-r6
perl-module-syslog - 5.14.2-r6
perl-module-tainted - 5.14.2-r6
perl-module-tap-base - 5.14.2-r6
perl-module-tap-formatter-base - 5.14.2-r6
perl-module-tap-formatter-color - 5.14.2-r6
perl-module-tap-formatter-console - 5.14.2-r6
perl-module-tap-formatter-console-parallelsession - 5.14.2-r6
perl-module-tap-formatter-console-session - 5.14.2-r6
perl-module-tap-formatter-file - 5.14.2-r6
perl-module-tap-formatter-file-session - 5.14.2-r6
perl-module-tap-formatter-session - 5.14.2-r6
perl-module-tap-harness - 5.14.2-r6
perl-module-tap-object - 5.14.2-r6
perl-module-tap-parser - 5.14.2-r6
perl-module-tap-parser-aggregator - 5.14.2-r6
perl-module-tap-parser-grammar - 5.14.2-r6
perl-module-tap-parser-iterator - 5.14.2-r6
perl-module-tap-parser-iterator-array - 5.14.2-r6
perl-module-tap-parser-iterator-process - 5.14.2-r6
perl-module-tap-parser-iterator-stream - 5.14.2-r6
perl-module-tap-parser-iteratorfactory - 5.14.2-r6
perl-module-tap-parser-multiplexer - 5.14.2-r6
perl-module-tap-parser-result - 5.14.2-r6
perl-module-tap-parser-result-bailout - 5.14.2-r6
perl-module-tap-parser-result-comment - 5.14.2-r6
perl-module-tap-parser-result-plan - 5.14.2-r6
perl-module-tap-parser-result-pragma - 5.14.2-r6
perl-module-tap-parser-result-test - 5.14.2-r6
perl-module-tap-parser-result-unknown - 5.14.2-r6
perl-module-tap-parser-result-version - 5.14.2-r6
perl-module-tap-parser-result-yaml - 5.14.2-r6
perl-module-tap-parser-resultfactory - 5.14.2-r6
perl-module-tap-parser-scheduler - 5.14.2-r6
perl-module-tap-parser-scheduler-job - 5.14.2-r6
perl-module-tap-parser-scheduler-spinner - 5.14.2-r6
perl-module-tap-parser-source - 5.14.2-r6
perl-module-tap-parser-sourcehandler - 5.14.2-r6
perl-module-tap-parser-sourcehandler-executable - 5.14.2-r6
perl-module-tap-parser-sourcehandler-file - 5.14.2-r6
perl-module-tap-parser-sourcehandler-handle - 5.14.2-r6
perl-module-tap-parser-sourcehandler-perl - 5.14.2-r6
perl-module-tap-parser-sourcehandler-rawtap - 5.14.2-r6
perl-module-tap-parser-utils - 5.14.2-r6
perl-module-tap-parser-yamlish-reader - 5.14.2-r6
perl-module-tap-parser-yamlish-writer - 5.14.2-r6
perl-module-term-ansicolor - 5.14.2-r6
perl-module-term-cap - 5.14.2-r6
perl-module-term-complete - 5.14.2-r6
perl-module-term-readline - 5.14.2-r6
perl-module-term-ui - 5.14.2-r6
perl-module-term-ui-history - 5.14.2-r6
perl-module-termcap - 5.14.2-r6
perl-module-test - 5.14.2-r6
perl-module-test-builder - 5.14.2-r6
perl-module-test-builder-module - 5.14.2-r6
perl-module-test-builder-tester - 5.14.2-r6
perl-module-test-builder-tester-color - 5.14.2-r6
perl-module-test-harness - 5.14.2-r6
perl-module-test-more - 5.14.2-r6
perl-module-test-simple - 5.14.2-r6
perl-module-text - 5.14.2-r6
perl-module-text-abbrev - 5.14.2-r6
perl-module-text-balanced - 5.14.2-r6
perl-module-text-parsewords - 5.14.2-r6
perl-module-text-soundex - 5.14.2-r6
perl-module-text-tabs - 5.14.2-r6
perl-module-text-wrap - 5.14.2-r6
perl-module-thread - 5.14.2-r6
perl-module-thread-queue - 5.14.2-r6
perl-module-thread-semaphore - 5.14.2-r6
perl-module-threads - 5.14.2-r6
perl-module-threads-shared - 5.14.2-r6
perl-module-tie-array - 5.14.2-r6
perl-module-tie-file - 5.14.2-r6
perl-module-tie-handle - 5.14.2-r6
perl-module-tie-hash - 5.14.2-r6
perl-module-tie-memoize - 5.14.2-r6
perl-module-tie-refhash - 5.14.2-r6
perl-module-tie-scalar - 5.14.2-r6
perl-module-tie-stdhandle - 5.14.2-r6
perl-module-tie-substrhash - 5.14.2-r6
perl-module-time - 5.14.2-r6
perl-module-time-gmtime - 5.14.2-r6
perl-module-time-hires - 5.14.2-r6
perl-module-time-local - 5.14.2-r6
perl-module-time-localtime - 5.14.2-r6
perl-module-time-piece - 5.14.2-r6
perl-module-time-seconds - 5.14.2-r6
perl-module-time-tm - 5.14.2-r6
perl-module-timelocal - 5.14.2-r6
perl-module-unicode - 5.14.2-r6
perl-module-unicode-collate - 5.14.2-r6
perl-module-unicode-collate-cjk-big5 - 5.14.2-r6
perl-module-unicode-collate-cjk-gb2312 - 5.14.2-r6
perl-module-unicode-collate-cjk-jisx0208 - 5.14.2-r6
perl-module-unicode-collate-cjk-korean - 5.14.2-r6
perl-module-unicode-collate-cjk-pinyin - 5.14.2-r6
perl-module-unicode-collate-cjk-stroke - 5.14.2-r6
perl-module-unicode-collate-locale - 5.14.2-r6
perl-module-unicode-collate-locale-af - 5.14.2-r6
perl-module-unicode-collate-locale-ar - 5.14.2-r6
perl-module-unicode-collate-locale-az - 5.14.2-r6
perl-module-unicode-collate-locale-ca - 5.14.2-r6
perl-module-unicode-collate-locale-cs - 5.14.2-r6
perl-module-unicode-collate-locale-cy - 5.14.2-r6
perl-module-unicode-collate-locale-da - 5.14.2-r6
perl-module-unicode-collate-locale-de-phone - 5.14.2-r6
perl-module-unicode-collate-locale-eo - 5.14.2-r6
perl-module-unicode-collate-locale-es - 5.14.2-r6
perl-module-unicode-collate-locale-es-trad - 5.14.2-r6
perl-module-unicode-collate-locale-et - 5.14.2-r6
perl-module-unicode-collate-locale-fi - 5.14.2-r6
perl-module-unicode-collate-locale-fil - 5.14.2-r6
perl-module-unicode-collate-locale-fo - 5.14.2-r6
perl-module-unicode-collate-locale-fr - 5.14.2-r6
perl-module-unicode-collate-locale-ha - 5.14.2-r6
perl-module-unicode-collate-locale-haw - 5.14.2-r6
perl-module-unicode-collate-locale-hr - 5.14.2-r6
perl-module-unicode-collate-locale-hu - 5.14.2-r6
perl-module-unicode-collate-locale-hy - 5.14.2-r6
perl-module-unicode-collate-locale-ig - 5.14.2-r6
perl-module-unicode-collate-locale-is - 5.14.2-r6
perl-module-unicode-collate-locale-ja - 5.14.2-r6
perl-module-unicode-collate-locale-kk - 5.14.2-r6
perl-module-unicode-collate-locale-kl - 5.14.2-r6
perl-module-unicode-collate-locale-ko - 5.14.2-r6
perl-module-unicode-collate-locale-lt - 5.14.2-r6
perl-module-unicode-collate-locale-lv - 5.14.2-r6
perl-module-unicode-collate-locale-mt - 5.14.2-r6
perl-module-unicode-collate-locale-nb - 5.14.2-r6
perl-module-unicode-collate-locale-nn - 5.14.2-r6
perl-module-unicode-collate-locale-nso - 5.14.2-r6
perl-module-unicode-collate-locale-om - 5.14.2-r6
perl-module-unicode-collate-locale-pl - 5.14.2-r6
perl-module-unicode-collate-locale-ro - 5.14.2-r6
perl-module-unicode-collate-locale-ru - 5.14.2-r6
perl-module-unicode-collate-locale-se - 5.14.2-r6
perl-module-unicode-collate-locale-sk - 5.14.2-r6
perl-module-unicode-collate-locale-sl - 5.14.2-r6
perl-module-unicode-collate-locale-sq - 5.14.2-r6
perl-module-unicode-collate-locale-sv - 5.14.2-r6
perl-module-unicode-collate-locale-sw - 5.14.2-r6
perl-module-unicode-collate-locale-tn - 5.14.2-r6
perl-module-unicode-collate-locale-to - 5.14.2-r6
perl-module-unicode-collate-locale-tr - 5.14.2-r6
perl-module-unicode-collate-locale-uk - 5.14.2-r6
perl-module-unicode-collate-locale-vi - 5.14.2-r6
perl-module-unicode-collate-locale-wo - 5.14.2-r6
perl-module-unicode-collate-locale-yo - 5.14.2-r6
perl-module-unicode-collate-locale-zh - 5.14.2-r6
perl-module-unicode-collate-locale-zh-big5 - 5.14.2-r6
perl-module-unicode-collate-locale-zh-gb - 5.14.2-r6
perl-module-unicode-collate-locale-zh-pin - 5.14.2-r6
perl-module-unicode-collate-locale-zh-strk - 5.14.2-r6
perl-module-unicode-normalize - 5.14.2-r6
perl-module-unicode-ucd - 5.14.2-r6
perl-module-unicore - 5.14.2-r6
perl-module-universal - 5.14.2-r6
perl-module-user-grent - 5.14.2-r6
perl-module-user-pwent - 5.14.2-r6
perl-module-utf8 - 5.14.2-r6
perl-module-utf8-heavy - 5.14.2-r6
perl-module-validate - 5.14.2-r6
perl-module-vars - 5.14.2-r6
perl-module-version - 5.14.2-r6
perl-module-vmsish - 5.14.2-r6
perl-module-warnings - 5.14.2-r6
perl-module-warnings-register - 5.14.2-r6
perl-module-xsloader - 5.14.2-r6
perl-modules - 5.14.2-r6
pkgconfig - 0.25-r3
pkgconfig-dev - 0.25-r3
pm-utils - 1.4.1-r1
pointercal - 0.0-r11
pointercal-xinput - 0.0-r4
polkit - 0.104-r8
procps - 3.2.8-r7
python-audio - 2.7.2-r3.17
python-codecs - 2.7.2-r3.17
python-compression - 2.7.2-r3.17
python-core - 2.7.2-r3.17
python-crypt - 2.7.2-r3.17
python-datetime - 2.7.2-r3.17
python-dbus - 1.0.0-r1
python-dev - 2.7.2-r3.17
python-difflib - 2.7.2-r3.17
python-elementtree - 2.7.2-r3.17
python-email - 2.7.2-r3.17
python-fcntl - 2.7.2-r3.17
python-html - 2.7.2-r3.17
python-image - 2.7.2-r3.17
python-imaging - 1.1.7-r3
python-io - 2.7.2-r3.17
python-json - 2.7.2-r3.17
python-lang - 2.7.2-r3.17
python-logging - 2.7.2-r3.17
python-math - 2.7.2-r3.17
python-mime - 2.7.2-r3.17
python-misc - 2.7.2-r3.17
python-multiprocessing - 2.7.2-r3.17
python-netclient - 2.7.2-r3.17
python-netserver - 2.7.2-r3.17
python-numbers - 2.7.2-r3.17
python-numpy - 1.4.1-r2
python-numpy-dev - 1.4.1-r2
python-pickle - 2.7.2-r3.17
python-pkgutil - 2.7.2-r3.17
python-pprint - 2.7.2-r3.17
python-pycairo - 1.10.0-r2
python-pyopenssl - 0.13-r0
python-re - 2.7.2-r3.17
python-readline - 2.7.2-r3.17
python-shell - 2.7.2-r3.17
python-simplejson - 2.2.1-r0
python-stringold - 2.7.2-r3.17
python-subprocess - 2.7.2-r3.17
python-syslog - 2.7.2-r3.17
python-terminal - 2.7.2-r3.17
python-textutils - 2.7.2-r3.17
python-threading - 2.7.2-r3.17
python-tornado - 2.2-r0
python-unittest - 2.7.2-r3.17
python-unixadmin - 2.7.2-r3.17
python-xml - 2.7.2-r3.17
python-zlib - 2.7.2-r3.17
randrproto-dev - 1:1.3.2-r0
renderproto-dev - 1:0.11.1-r0
rgb - 1:1.0.4-r7.0
rsync - 3.0.9-r0
rt-tests - 1:0.83-r2
screen - 4.0.3-r3
sed - 4.2.1-r3
sg3-utils - 1.31-r1
shadow - 4.1.4.3-r8
shadow-securetty - 4.1.4.3-r1
shared-mime-info - 0.91-r4
shared-mime-info-data - 0.91-r4
swig - 2.0.0-r1.0
swig-dev - 2.0.0-r1.0
systemd - v44-45-g3eff420-r27
systemd-analyze - v44-45-g3eff420-r27
systemd-compat-units - 1.0-r15
systemd-serialgetty - 1.0-r3
sysvinit-pidof - 2.88dsf-r6
tar - 1.26-r1
task-basic - 1.0-r8
task-boot - 1.0-r57
task-gnome - 1.0-r12
task-gnome-fonts - 1.0-r12
task-gnome-gstreamer - 1.0-r12
task-gnome-perl - 1.0-r12
task-gnome-themes - 1.0-r12
task-gnome-xserver-base - 1.0-r12
task-sdk-target - 1.0-r0
task-ti-test - 1.0-r0
task-x11-server - 1.0-r9
timestamp-service - 1.0-r0
tinylogin - 1.4-r8
tslib-calibrate - 1.0+gitr1+e17263ef401ee885a27d649b90b577cfb44500e0-r8
tslib-conf - 1.0+gitr1+e17263ef401ee885a27d649b90b577cfb44500e0-r8
tslib-tests - 1.0+gitr1+e17263ef401ee885a27d649b90b577cfb44500e0-r8
ttf-dejavu-common - 2.23-r4
ttf-dejavu-sans - 2.23-r4
ttf-dejavu-sans-mono - 2.23-r4
ttf-liberation-mono - 0.2-r4
ttf-liberation-sans - 0.2-r4
ttf-liberation-serif - 0.2-r4
tzdata - 2012b-r0
udev - 182-r0
udev-systemd - 182-r0
udev-utils - 182-r0
udisks - 1.0.4-r4
update-alternatives-cworth - 1:0.1.8+svnr633-r9.0
update-modules - 1.0-r13
update-modules-dev - 1.0-r13
update-rc.d - 0.7-r5
upower - 0.9.14-r1
usbutils - 0.91-r3
usbutils-ids - 0.91-r3
util-linux - 2.21-r5
util-linux-agetty - 2.21-r5
util-linux-blkid - 2.21-r5
util-linux-cfdisk - 2.21-r5
util-linux-dev - 2.21-r5
util-linux-fdisk - 2.21-r5
util-linux-fsck - 2.21-r5
util-linux-losetup - 2.21-r5
util-linux-mcookie - 2.21-r5
util-linux-mkfs - 2.21-r5
util-linux-mount - 2.21-r5
util-linux-readprofile - 2.21-r5
util-linux-sfdisk - 2.21-r5
util-linux-swaponoff - 2.21-r5
util-linux-umount - 2.21-r5
util-macros-dev - 1:1.17-r0
vim - 7.2.446-r11.3
vim-vimrc - 7.2.446-r11.3
vte-termcap - 0.28.2-r3
wpa-supplicant - 0.7.3-r8
wpa-supplicant-cli - 0.7.3-r8
wpa-supplicant-passphrase - 0.7.3-r8
wv - 1.2.0-r4
xauth - 1:1.0.6-r0
xbmc - 11.0-r13+gitr3+1d975a04c6686b9a82f63a4c605a5c5c5f84d0e8
xcb-proto-dev - 1.7-r0
xcmiscproto-dev - 1:1.2.1-r0
xdg-utils - 1.0.2-r0
xextproto-dev - 1:7.2.0-r0
xf86-input-evdev - 2:2.6.0-r17.0
xf86-video-fbdev - 2:0.4.2-r17.0
xf86bigfontproto-dev - 1:1.2.0-r1
xhost - 1:1.0.4-r0
xinetd - 2.3.14-r1
xinit - 1:1.3.2-r0
xinput - 1.5.3-r7
xinput-calibrator - 0.7.5-r6
xkbcomp - 1.2.3-r0
xkeyboard-config - 2.1-r1
xproto-dev - 1:7.0.22-r1
xrandr - 1:1.3.5-r1
xrdb - 1.0.9-r6
xserver-xf86-config - 0.1-r12.2
xserver-xorg - 2:1.11.2-r1
xset - 1:1.2.2-r0
xterm - 277-r0
xtrans-dev - 1:1.2.6-r0
xvinfo - 1:1.1.1-r0
xz - 5.0.3-r1
xz-dev - 5.0.3-r1
yajl - 2.0.3-r0
yavta - 0.0-r1
zip - 3.0-r1
zip-dev - 3.0-r1
</pre>

{{YoderFoot}}

ECE497 Notes on Ubuntu and Audio Cape

2013-05-18T16:05:20Z

Yoder:

[[Category:EmbeddedBeagleClass]]
[[Category:ECE497Notes |ubuntu]]

To install Ubuntu on the BeagleBone follow the instructions at http://elinux.org/BeagleBoardUbuntu

In Ubuntu, to get ALSA to work with the BeagleBone Audio cape, the following modules should be specified in '/etc/modules'

snd_soc_tlv320aic3x
snd_soc_davinci
snd_soc_davinci_mcasp
snd_soc_evm

You can test the audio by running `speaker-test`. Also running `aplay -l` will show a list of available sound cards. If the sound card is not shown, run `lsmod` and `dmesg` and make sure the kernel modules above have loaded without errors.

Rakarrack is a very nice open source audio effects processor that looks just like a guitar pedalboard. It uses the Jack Audio Connection Kit to stream audio allowing for realtime audio effects

Start by installing jackd2. This requires a patch for the current version (1.9.10) on ARM (see http://jack-audio.10948.n7.nabble.com/Jack-Devel-jack2-on-ARM-patch-td15962.html). Run the recipe found at that page (copied below with a couple modifications).

wget http://jack-audio.10948.n7.nabble.com/attachment/15962/0/jack2_armel.diff
apt-get source jackd2
cd jackd2-1.9.8~dfsg.4+20120529git007cdc37
patch -p1 -i ../jack2_armel.diff
dpkg-buildpackage -rfakeroot -uc -b
cd ..
sudo dpkg -i libjack-jackd2-0_1.9.8~dfsg.4+20120529git007cdc37-2ubuntu1_armhf.deb jackd2_1.9.8~dfsg.4+20120529git007cdc37-2ubuntu1_armhf.deb

Then install Rakarrack by running the following:

sudo apt-get install rakarrack

The installation should install jackd as a dependency. To check the installed jack packages run the following:

dpkg --get-selections | grep jack

You should see something like this:

ubuntu@arm:~$ dpkg --get-selections | grep jack
jack deinstall
jackd install
jackd1 deinstall
jackd2 install
libjack-jackd2-0:armhf install
libjack0:armhf deinstall
qjackctl deinstall

Now you should be able to run the rakarrack GUI. Use `ssh -X ubuntu@192.168.0.XXX` to connect to the BeagleBone with X11 forwarding and then run `rakarrack`. The program should be able to find jackd by itself. If not try killing the jack processes and restart rakarrack. One way to do this is run `ps -AL | grep jack`, and then run `kill -9` with the pid number.

If you have problems with jackd not running you can try running in manually (make sure it is not running in the background first). Run `jackd -d alsa` and the output should look somethings like the following:

ubuntu@arm:/etc$ jackd -d alsa
jackdmp 1.9.10
Copyright 2001-2005 Paul Davis and others.
Copyright 2004-2013 Grame.
jackdmp comes with ABSOLUTELY NO WARRANTY
This is free software, and you are welcome to redistribute it
under certain conditions; see the file COPYING for details
JACK server starting in realtime mode with priority 10
creating alsa driver ... hw:0|hw:0|1024|2|48000|0|0|nomon|swmeter|-|32bit
control device hw:0
configuring for 48000Hz, period = 1024 frames (21.3 ms), buffer = 2 periods
ALSA: final selected sample format for capture: 32bit integer little-endian
ALSA: use 16 periods for capture
ALSA: final selected sample format for playback: 32bit integer little-endian
ALSA: use 16 periods for playback

When Rakarrack opens, it may warn you that your CPU is not fast enough to run some of the audio effects (e.g. convolutron). See (http://forums.fedoraforum.org/archive/index.php/t-254181.html) for some tips on mitigating performance problems. If you crash jackd, you can easily kill its processes as shown above and restart Rakarrack (there is no need to reboot or anything).

Some things to improve performance (a bit...)

Increase clock speed of BeagleBone by running the following:

sudo cpufreq-set -f 720MHz
sudo cat /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_cur_freq

The output of that last command should be '720000'

Also in Rakarrack go to 'Settings->Preferences->Audio' and lower all the downsample settings to '4000' and the up to 'Fastest'

With these settings, I was able to get the Expander, Sustainer, Looper, and Dual Flange to work without crasing jackd

ECE497 Notes on StarterWare

2013-05-18T16:04:41Z

Yoder:

[[Category:ECE497Notes |s]]
{{YoderHead}}

[http://processors.wiki.ti.com/index.php/StarterWare StarterWare] is a bare bones way to use the Beagle.

[http://processors.wiki.ti.com/index.php/AM335X_StarterWare_Environment_Setup Here] is info on setting it up.

{{YoderFoot}}

ECE497 Notes on Rtlizer

2013-05-18T16:03:49Z

Yoder:

[[Category:ECE497Notes |Rt]]

[https://github.com/csete/rtlizer Rtlizer] is a simple spectrum analyzer written for the BeagleBone. Rtlizer uses [http://www.rtlsdr.org/ rtl-sdr] a command line tool to interface with software defined radios such as the [http://www.nooelec.com/store/software-defined-radio/sdr-receivers/tv28tv2.html#.UU5gGXGx0ak R820T] used here.

== Installation ==

Instructions for installing rtl-sdr and rtlizer can be found [http://www.oz9aec.net/index.php/beaglebone/480-rtlizer here]. They are copied here for convenience.

Run the following as root on the BeagleBone:

git clone git://git.osmocom.org/rtl-sdr.git
cd rtl-sdr/
autoreconf -i
./configure
make
make install
mv /usr/local/lib/pkgconfig/librtlsdr.pc /usr/lib/pkgconfig
ldconfig

git clone git://github.com/csete/rtlizer.git
cd rtlizer
./build-target

=== How to Run ===

In X11 run the following:

cd rtlizer
rtlizer 640x360+0+0

== Conclusion ==

[http://osmocom.rtlsdr.org//trac/wiki/rtl-sdr This site] contains more information about rtl-sdr including a long list of SDR applications that use the library.

The R820T is a very nice (and cheap) SDR with some nice functionality. One thing that it cannot do however (at least in the US) is function as a TV tuner. The tuner uses the DVB-T standard. ATSC is the standard used for digital TV broadcasting in the US.

== Future Work ==

It would be interesting to do some radio decoding on the BeagleBone using rtl-sdr as a back-end to the R820T. A possible application could be something like ADS-B (aircraft tracking) or NOAA (weather satellite) decoding.

ECE497 Notes on Rakarrack

2013-05-18T16:03:32Z

Yoder:

[[Category:ECE497Notes |Rak]]

[http://rakarrack.sourceforge.net/ Rakarrack] is an open source effects processor that emulates a guitar effects pedal board. It can be run easily in Ubuntu on the BeagleBone. Below is the installation process for use with the [http://circuitco.com/support/index.php?title=BeagleBone_Audio BeagleBone Audio Cape].

*Note: The following is tested on Ubuntu 12.10 running version 3.2.33-psp26 of the kernel.

== Ubuntu Installation ==

To install Ubuntu on the BeagleBone follow the instructions found on the [http://elinux.org/BeagleBoardUbuntu BeagleBoardUbuntu elinux site].

login: ubuntu
password: temppwd

Run `sudo apt-get update` and `sudo apt-get upgrade` until there are no more updates/upgrades to install.

=== ALSA ===

In Ubuntu, to get ALSA to work with the BeagleBone Audio cape, the following modules need to be specified in '/etc/modules'

snd_soc_tlv320aic3x
snd_soc_davinci
snd_soc_davinci_mcasp
snd_soc_evm

You can test the audio by running `speaker-test`. Also running `aplay -l` will show a list of available sound cards. If the sound card is not shown, run `lsmod` and `dmesg` and make sure the kernel modules above have loaded without errors.

== Rakarrack Installation ==

Rakarrack uses the [http://jackaudio.org/ Jack Audio Connection Kit] to route audio between applications.

=== JACK ===

Start by installing jackd2. This requires a patch for the current version (jackd-1.9.10) on ARM (see [http://jack-audio.10948.n7.nabble.com/Jack-Devel-jack2-on-ARM-patch-td15962.html this forum post]). Run the recipe below (copied from that post with a couple modifications).

wget http://jack-audio.10948.n7.nabble.com/attachment/15962/0/jack2_armel.diff
apt-get source jackd2
cd jackd2-1.9.8~dfsg.4+20120529git007cdc37
patch -p1 -i ../jack2_armel.diff
dpkg-buildpackage -rfakeroot -uc -b
cd ..
sudo dpkg -i libjack-jackd2-0_1.9.8~dfsg.4+20120529git007cdc37-2ubuntu1_armhf.deb jackd2_1.9.8~dfsg.4+20120529git007cdc37-2ubuntu1_armhf.deb

=== Rakarrack ===

Then install Rakarrack by running the following:

sudo apt-get install rakarrack

The installation should install jackd as a dependency. To check the installed jack packages run the following:

dpkg --get-selections | grep jack

You should see something like this:

ubuntu@arm:~$ dpkg --get-selections | grep jack
jack deinstall
jackd install
jackd1 deinstall
jackd2 install
libjack-jackd2-0:armhf install
libjack0:armhf deinstall
qjackctl deinstall

== System Configuration ==

Before running anything we need to make sure that the BeagleBone is running at its maximum clock speed. To do this run the following:

sudo cpufreq-set -f 720MHz
sudo cat /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_cur_freq

The output of that last command should be '720000'

*Note: The BeagleBone needs to be running off the wall adapter to reach maximum clock rate

=== JACK ===

Next, start JACK by running the following:

jackd -d alsa -p 256 -n 16 -S

This tells JACK that we wan to use alsa with a 16 period 256 samples/period buffer in 16-bit mode. This should be enough delay to not cause too many XRuns in JACK but not too big to be noticeable. The output should look somethings like the following:

ubuntu@arm:~$ jackd -d alsa -p 256 -n 16 -S
jackdmp 1.9.10
Copyright 2001-2005 Paul Davis and others.
Copyright 2004-2013 Grame.
jackdmp comes with ABSOLUTELY NO WARRANTY
This is free software, and you are welcome to redistribute it
under certain conditions; see the file COPYING for details
JACK server starting in realtime mode with priority 10
creating alsa driver ... hw:0|hw:0|256|16|48000|0|0|nomon|swmeter|-|16bit
control device hw:0
configuring for 48000Hz, period = 256 frames (5.3 ms), buffer = 16 periods
ALSA: final selected sample format for capture: 16bit little-endian
ALSA: use 16 periods for capture
ALSA: final selected sample format for playback: 16bit little-endian
ALSA: use 16 periods for playback

=== Rakarrack ===

Now you should be able to run the rakarrack GUI. Use `ssh -X ubuntu@192.168.0.XXX` to connect to the BeagleBone with X11 forwarding and then run `rakarrack`.

*Note: This version of the kernel does not have a working USB gadget module so ethernet over USB does not work so the BeagleBone needs to be connected to the network.

The program should be able to find jackd by itself. If not kill the JACK processes and rerun the configuration. One way to do this is run `ps -AL | grep jack`, and then run `kill -9` with the pid number.

When Rakarrack opens, it may warn you that your CPU is not fast enough to run some of the audio effects (e.g. convolutron). Don't worry about this too much.

In Rakarrack go to 'Settings->Preferences->Audio' and lower all the downsample rates to '4000' and change all the down and up sampling types to 'Linear'. We could get a little more performance out of 'Zero Order', but this sampling does not interpolate so the quality isn't great.

== Conclusion ==

With these settings we are able to run any single effect in Rakarrack without causing XRuns in JACK. Some effects can be chained together, but others are just too computationally complex.

== Future Work ==

An interesting follow up project would be to see if another embedded Linux board (e.g. BeagleBoard xM, PandaBoard, etc.) could run Rakarrack at its default settings (or maybe its maximum settings?).

*Note: On multicore systems JACK may require some special setup for [http://jackaudio.org/linux_rt_config realtime processing]

ECE497 Notes on Qt

2013-05-18T16:03:00Z

Yoder:

[[Category:ECE497Notes |qt]]
{{YoderHead}}

[http://qt.nokia.com/ Qt] is one of the many UI frameworks that runs on the Beagle. It also runs on many other platforms such as Microsoft Windows, Mac OS X, and Linux, and it appears to be one of the more popular choices for the Beagle. It even runs on [http://qt.nokia.com/products/qt-for-mobile-platforms dumb cell phones]. We'll be using it with X11, however there is an [http://developer.qt.nokia.com/wiki/Support_for_Embedded_Linux embedded version] that doesn't need X.

== Video ==

[https://plus.google.com/app/basic/stream/z13ah33j3xq5cpxti225yxthikrhfn3tr]

== Installation ==

[http://tigraphics.blogspot.com/2013/01/qt-500-final-dec-2012-available-on-ti.html TI Graphics site] has the latest version of QT.

Qt can be developed solely on the Beagle, but I suggest you install it on both your host and the Beagle. Compilations on the Beagle may only take 20 or 30 seconds, but run much faster on the host.

=== Installing v6 ===

I'm running with v6 since it's an easy download on both the host and Beagle. You also get the sources for the examples this way.

==== Installing on the host ====

I think this is all I did on the host. This assumes you have oe installed.

host$ '''source ~/.oe/environment-2008'''
host$ '''bitbake qt4-x11-free-gles'''

==== Installing on the Beagle ====

Here's what I've installed on the Beagle

beagle$ '''opkg update'''
beagle$ '''opkg install qt4-x11-free''' # 3 minutes
beagle$ '''opkg install qmake2''' # 1 minute
beagle$ '''opkg install qt4-x11-free-dev''' # 4 minutes
beagle$ '''opkg install qt4-x11-free-doc''' # 5 minutes

I had to hack a couple of things before running qmake.

beagle$ '''cd /usr/bin'''
beagle$ '''ln -s moc moc-qt4'''
beagle$ '''ln -s uic uic-qt4'''
beagle$ '''ln -s qmake-qt4 qmake'''

beagle$ '''source /usr/share/qt4/environment-setup'''

Be sure to source the setup file before running qmake for the first time.

Check out the qt demos and documentation.

beagle$ '''qtdemo'''
beagle$ '''midori file:///usr/share/doc/qt4/html/index.html'''

The following appears to load some qt examples with source code in /usr/share/ICS. You'll also find examples in /usr/bin/qt4/examples.

beagle$ '''opkg install linuxtag-ics''' # 1 minute

=== Installing v5 ===

Version 5 is what you get when you use the package managers. I don't know how to get the source for the examples with this approach.

==== Installing on the host ====

Just run:

host$ '''sudo apt-get update'''
host$ '''sudo apt-get install libqwt-dev''' # 1 minute
host$ '''opkg intall libqwt-examples''' # 1 minute

==== Installing on the Beagle ====

Just run:

beagle$ '''opkg update'''
beagle$ '''opkg intall libqwt-dev''' # 1 minute
beagle$ '''opkg intall libqwt-examples''' # 1 minute

== Qt Tutorials ==

=== Widgets ===

There are several nice Qt Tutorials [http://doc.qt.nokia.com/4.7/tutorials.html here]. I suggest you start with the [http://doc.qt.nokia.com/4.7/widgets-tutorial.html Widgets Tutorial]. Here's how you can run the examples on the Beagle.

# Go to the [http://doc.qt.nokia.com/4.7/tutorials-widgets-toplevel.html Creating a Window] tutorial and download the '''main.cpp''' and '''toplevel.pro''' files. Put them in their own directory.
# Run '''qmake'''. (Be sure you have sourced the file noted above.) This will create a Makefile.
# Run '''make'''. This should compile the program. It takes about 30 seconds for the first make.
# Do an '''ls''' to see what files were created. You should see '''toplevel'''. Run it.
# Congratulations, you've just compiled and run your first Qt program.

Work through the rest of the widgets tutorials to learn about building at Qt from the bottom up. The [http://doc.qt.nokia.com/4.7/tutorials-addressbook.html Address Book] tutorials look like they are also a good place to explore.

=== Qt Designer ===

It's possible to build a user interface from the command line, building a graphics user interface is more easily done with a graphical program. [http://doc.qt.nokia.com/4.7/designer-manual.html Qt Designer] is Qt's tool for designing and building graphical user interfaces (GUIs) from Qt components. The [http://doc.qt.nokia.com/4.7/designer-quick-start.html Qt Designer Tutorial] is a good overview of what Designer can do. Designer runs on the host and the Beagle and should already be installed.

The Qt Designer tutorial ends rather quickly. I suggest you follow it up by looking at the [http://doc.qt.nokia.com/4.7/examples-designer.html Qt Designer Examples]. Here you will learn different ways to take the '''*.ui''' file created by Designer and use it with your other Qt code.

== Useful Links ==

Here are some usefule links I've found.

; [http://qt.nokia.com/ The Qt site]
: It's a bit overwhelming at first, but gives a good idea what Qt can do, how it can do it, and where it's doing it.

; [http://doc.trolltech.com/4.7/index.html Qt Reference Documenation]
: This looks like a nice reference.

; [http://labs.qt.nokia.com/2009/11/20/building-qt-to-make-use-of-the-beagle-boards-sgx-gpu/ Building Qt to make use of the Beagle board’s SGX GPU]
: There is a version of Qt that uses the Beagle's SGC to render the 3D stuff. I'm not doing 3D right now, so I haven't looked into it.

; [http://processors.wiki.ti.com/index.php/Building_Qt Building Qt]
: This is TI's site.

; [http://qt.nokia.com/products/platform/qt-for-embedded-linux/ Embedded Linux Qt]
: If you are thinking small, maybe you don't want X running on your Beagle. If so, look at Qt Embedded. It write straight to the frame buffer.

; [http://treyweaver.blogspot.com/2010/10/setting-up-qt-development-environment.html Setting Up Qt Development Environment for BeagleBoard-xM]
: This site has some nice instructions on getting QT going on the Beagle by recompiling everything. I don't think recompiling is really necessary. It's set up for using Qt embedded.

== Qt Quick and Qt Creator ==

Qt Quick is another way of building a UI. [http://qt.nokia.com/qtquick/ Qt Quick] is based on JavaScript, HTML and CSS. [http://qt.nokia.com/products/developer-tools Qt Creator] is a cross-platform integrated development environment (IDE) tailored to the needs of Qt developers; however it doesn't appear to run on the Beagle. I need to look into this some more.

I'm working through [http://doc.trolltech.com/qtcreator-2.2/creator-qml-application.html this] example. I can't change '''mousearea1''' to '''MouseArea''' to match the figure. I think something is missing in the instructions.

The Transitions section has some details missing:
<pre>

transitions: [
Transition {
from: "*"; to: "State1"
NumberAnimation {
properties: "x,y";
duration: 1000
}
}
]
</pre>

== Real-time Plotting - QWT ==

QWT is short for Qt Widgets for Technical Applications. It is a collection of widgets and support classes for creating technical applications. I hope to use it to do real-time plotting on the Beagle.

[http://qwt.sourceforge.net/ Here] is the main qwt site. [http://www.digitalfanatics.org/projects/qt_tutorial/chapter11.html Here] is some info on QWT. I think it might be able to plot data as it comes in.

Here's how I think I installed it on the host.

host$ '''svn co https://qwt.svn.sourceforge.net/svnroot/qwt/branches/qwt-6.0''' # This is straight from the qwt site.
host$ '''cd qwt-6.0'''
host$ '''gedit qwtconfig.pri'''

Around line 108, uncomment <code>QWT_CONFIG += QwtExamples</code>. This will compile the examples too.

host$ '''qmake-qt4'''
host$ '''make'''

After a while it should be ready to run. Explore the '''examples''' folder. The Makefiles are setup to put all the binarys in examples/bin. Try running them.

=== On the Beagle ===
Here's what I did on the Beagle.

beagle$ '''svn co https://qwt.svn.sourceforge.net/svnroot/qwt/branches/qwt-6.0'''
beagle$ '''source /usr/share/qt4/environment-setup'''
beagle$ '''cd qwt-6.0'''
beagle$ '''qmake'''
beagle$ '''make'''

The compile took about 20 minutes without the examples. The examples took an additional 17 minutes. The lib files don't get copied to /usr/lib (even with make install), so I copied them by hand.

beagle$ '''cd lib'''
beagle$ '''cp * /usr/lib'''

Now try an example.

beagle$ '''cd ../examples/bode'''
beagle$ '''qmake'''
beagle$ '''make'''
beagle$ '''../bin/bode'''

You will now see a bode plot. They the '''Zoom''' and '''Export''' buttons.

Note: All the example Makefiles are set up to install the executable in the examples/bin directory.

{{YoderFoot}}

ECE497 Notes on Power Measurement

2013-05-18T16:02:41Z

Yoder:

[[Category:ECE497Notes |P]]
{{YoderHead}}

[https://groups.google.com/forum/#!topic/beagleboard/s3zIpN_9lig This] looks like a good post to start with to learn how to measure the Beagle's power consumption.

[https://groups.google.com/forum/?fromgroups#!topic/beagleboard/8PqigpF1VEk Here's] another post.

{{YoderFoot}}

ECE497 Notes on node.js

2013-05-18T16:01:25Z

Yoder:

[[Category:ECE497Notes |node]]
{{YoderHead}}

I'm working up and example on [http://nodejs.org/ node.js]. Here are some notes.

== Installing ==
=== Beagle ===

beagle$ opkg update
beagle$ opkg install nodejs

== Links ==

* [http://www.nodebeginner.org/ nodebeginner.org] looks like a good tutorial.
* [http://nodeguide.com/ http://nodeguide.com/]
* [http://nodetuts.com/ nodetuts.com]
* [http://elinux.org/images/b/ba/Elc2011_kridner.pdf Elc2011_kridner.pdf] looks like some notes from Jason.
* [http://debuggable.com/posts/understanding-node-js:4bd98440-45e4-4a9a-8ef7-0f7ecbdd56cb Understanding node.js]
* [http://howtonode.org/ How to node]. Looks like this also has some nice JavaScript tutorials.
* YouTube intro to [http://www.youtube.com/watch?v=jo_B4LTHi3I&feature=share node.js] (About an hour.)
* [http://blog.mixu.net/2011/02/01/understanding-the-node-js-event-loop/ Understanding the node.js event loop]
* [http://coding.smashingmagazine.com/2011/09/16/useful-node-js-tools-tutorials-and-resources/ Useful node.js tools]
** [http://shinetech.com/thoughts/thought-articles/139-asynchronous-code-design-with-nodejs Asynchronous Code Design with Node.js]
* [http://www.cambus.net/setting-up-a-node-js-development-environment-with-npm-and-cloud9-ide-installed-locally/ Installing node.js, cloud9 and npm]
* [http://cloud9ide.posterous.com/never-commit-to-your-master cloud9] development process.
* [http://nodemanual.org/latest/ Manual] for node.js
* [http://net.tutsplus.com/tutorials/javascript-ajax/getting-started-with-node-js-and-geddy Geddy] and node.js. Geddy is a simple and structured MVC (model, view, controller) framework for Node.js. The tutorial is too detailed for what I'm looking for. [http://net.tutsplus.com/tutorials/javascript-ajax/creating-a-to-do-list-app-with-node-js-and-geddy/ More geddy]
* [http://blog.nodejs.org/2012/04/25/profiling-node-js/ Profiling node.js]
* [http://sharejs.org ShareJS – Live concurrent editing in your app]
* [https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html Web Audio API]
* [http://www.chromium.org/developers/meet-the-web-platform-companion Web platform]
* [http://engineering.linkedin.com/nodejs/blazing-fast-nodejs-10-performance-tips-linkedin-mobile Blazing fast nose.js]
* [http://nikhilm.github.com/uvbook/ libuv book]

* [http://www.manning.com/cantelon/ Node.js in Action]. Buy this one. It looks pretty good. It pointed me to the following two links.
* [https://developer.mozilla.org/en/A_re-introduction_to_JavaScript A re-introduction to JavaScript]
* [http://eleventyone.done.hu/OReilly.JavaScript.The.Good.Parts.May.2008.pdf JavaScript: The Good Parts]. This may be a pirated copy. Better buy the real one.
* Install '''jslint''' for node.js with <code>sudo npm -g install jslint</code>. Details: [https://github.com/reid/node-jslint node-jslint].

[http://codehenge.net/blog/2011/12/getting-started-with-node-js-and-socket-io-v0-7-part-2/ Socket.io] looks like a good way to pass data to the browser.

=== Examples ===
* [http://csanz.posterous.com/intro-to-nodejs-slide-show-app-written-in-nod intro to node.js slide show app written in node.js]
* [http://maxogden.com/node-streams node streams]
* [http://summerofnodejs.com/ Summer of node.js]
* [http://cestfait.ch/content/chat-webapp-nodejs chat-webapp-nodejs]
* [http://shapeshed.com/creating-a-basic-site-with-node-and-express/ Creating a Basic Site With node.js and Express]
* [http://mustafaakin.wordpress.com/2012/04/28/wsftp-file-transfer-over-websockets/ WSFTP: File Transfer over Websockets]
* [http://www.chrissharkey.com/programming-blog/2012/03/12/making-an-hilarious-irc-bot-in-node-js MAKING AN HILARIOUS IRC BOT IN COFFEESCRIPT USING NODE.JS]

== Cloud9 ==

Somehow [http://cloud9ide.com/yoder Cloud9] fits in with this.

I'm trying to get cloud9 running on the Beagle.

beagle$ '''opkg update'''
beagle$ '''opkg install nodejs''' (1min 6 sec)
beagle$ '''opkg install nodejs-dev''' (I don't know if this is needed.)

Something from Jason

beagle$ '''opkg install bonescript'''
beagle$ '''opkg install cloud9'''

Here’s how to get npm according to http://npmjs.org/

beagle$ '''opkg install curl''' (1m23)
beagle$ '''opkg install nodejs''' (1m6)
beagle$ '''curl http://npmjs.org/install.sh | sh''' (1m5)

It's said [https://groups.google.com/forum/#!topic/beagleboard/uGp90z-BJkc this] will work on a current distribution of Angstrom, but it doesn't work for me.
beagle$ '''opkg install cloud9'''

=== non-Beagle ===

Here are instructions for a non-Beagle install from [https://groups.google.com/forum/#!starred/cloud9-ide/L4DSGZS4KmM here].

host$ '''git clone git://github.com/ajaxorg/cloud9.git''' (16 seconds)
host$ '''cd cloud9'''
host$ '''bin/cloud9.sh'''

then
host$ '''node ./bin/cloud9.js'''

== gitting examples ==

git clone git://gitorious.org/~Jadon/beagleboard-validation/jadons-education.git ''(10s)''

{{YoderFoot}}

ECE497 Notes on Kinect

2013-05-18T16:01:00Z

Yoder:

[[Category:ECE497Notes |K ]]
{{YoderHead}}

[http://www.xbox.com/en-US/kinect Microsoft's Kinect] sensor has created great interest in the Beagle Community.

Here are notes on installing the third party drivers from [http://www.omekinteractive.com/ Omek].

== Downloading ==

I got the 4 files from [http://support.omekinteractive.com/index.php?/TI/managedownloads/Download/View/19/7/beagleboard-xm-installation-and-documentation here]. Here's the files I have

host$ '''ls -sh'''
<pre>
total 65M
4.0K beagle-omek
54M beckon-image-2.4.16175.tar.gz
4.0K Beckon-SDK-2.4.16236
11M beckon-sdk-2.4.16236.tar.gz
4.0K create_sd.txt
4.0K mkcard.sh
1.1M omek beckon sdk, ti dm3730 edition -- developer guide.pdf
4.0K readme
4.0K UsersGuide
</pre>

== Installing ==

I'm getting this error.

host$ '''sudo bash mkcard.sh /dev/mmcblk0 beagle-omek/'''
<pre>
Using image beagle-omek/
using device /dev/mmcblk0
.
You are about to totaly erase the device, are you sure (yes/no) ?yes
1024+0 records in
1024+0 records out
1048576 bytes (1.0 MB) copied, 0.382056 s, 2.7 MB/s
Disk /dev/mmcblk0 doesn't contain a valid partition table
DISK SIZE - 8010072064 bytes
CYLINDERS - 973
Checking that no-one is using this disk right now ...
OK

Disk /dev/mmcblk0: 973 cylinders, 255 heads, 63 sectors/track

sfdisk: ERROR: sector 0 does not have an msdos signature
/dev/mmcblk0: unrecognized partition table type
Old situation:
No partitions found
New situation:
Units = cylinders of 8225280 bytes, blocks of 1024 bytes, counting from 0

Device Boot Start End #cyls #blocks Id System
/dev/mmcblk0p1 * 0+ 8 9- 72261 c W95 FAT32 (LBA)
/dev/mmcblk0p2 9 972 964 7743330 83 Linux
/dev/mmcblk0p3 0 - 0 0 0 Empty
/dev/mmcblk0p4 0 - 0 0 0 Empty
Successfully wrote the new partition table

Re-reading the partition table ...

If you created or changed a DOS partition, /dev/foo7, say, then use dd(1)
to zero the first 512 bytes: dd if=/dev/zero of=/dev/foo7 bs=512 count=1
(See fdisk(8).)
done partitioning.
Cant find boot partition /dev/mmcblk01
Cant find rootfs partition in /dev/mmcblk02
mount: special device /dev/mmcblk01 does not exist
</pre>
Failed to mount /dev/mmcblk0'''1'''.

The problem is it's looking for /dev/mmcblk0'''1''' and on my Ubuntu 10.4 it appears at /dev/mmcblk0'''p1'''.

I modified '''mkcard.sh''' to add the '''p''' and after a little fussing it worked!

== Running ==

It booted up and runs fine. There is no X windows, rather the one demo uses QT embedded. QT embedded writes straight to the framebuffer and doesn't need X.

== Porting ==

I'm now in the process of seeing if I can copy the demos over to an SD card that I've been doing other development on. My SD isn't set up for QT embedded, so I'm trying:

beagle$ '''opkg update'''
beagle$ '''opgk install qt4-embedded-tools''' # 5 minutes
beagle$ '''opgk install qt4-embedded-static''' # 2.5 minutes
beagle$ '''opgk install qt4-embedded-fonts''' # 2.5 minutes

These times running on a rather slow network at home. I don't know if the 'static' needs to be installed.

Next I went to the SD that was working with the Kinect and copied /usr/lib/libOpenNI.* to /usr/lib on the target SD card. I now get the following error.

beagle$ '''./QtTracking -qws'''
Error creating sensor.
Failed to initialize tracking !

I'm guess I don't have the DSP stuff setup right.

[http://youngindiafellowship.academia.edu/JatinSharma/Blog/48864/OpenNI-on-Beagle-Board-XM This] might help with the openNI port.

{{YoderFoot}}

ECE497 Notes on Installing Angstrom via Narcissus

2013-05-18T16:00:34Z

Yoder:

[[Category:ECE497Notes |N ]]

Here's another precompiled approach that creates a complete disk image, but gives you some control over what is in the image. The first listed creates the image used for the ICASSP 2011 tutorial/workshop. The second one does an older image.

== ETC 2011 image ==

The ETC image is pretty much the same as the FIE image, but with a couple of things cleaned up. I moved to using git for managing the exercises folder. There some gpio and pwm examples.

== FIE 2011 image ==

The FIE image is pretty much the same as the ICASSP image, but with a couple of things cleaned up.

== ICASSP 2011 image ==

This is the image that Daniel Allred at TI created to support c6run.

Make a beagleboard boot image and SDK image from [http://narcissus.angstrom-distribution.org/ Narcissus]. These steps are more or less in line from those taken [http://groups.google.com/group/beagleboard/browse_thread/thread/6b57d7dc2dbce7c3 here].

* Select '''beagleboard''' as the machine
* Select a unique name (or use the random one provided)
* Select '''advanced''' for options
** Select '''stable 2011.03''' for base of rootfs
** Select '''regular''' base system
** Select '''udev''' for /dev manager
** Select '''sysvinit''' for init manager
** Select '''OMAP SD image''' for image type
** Software manifest is '''no''' (really it doesn't matter unless you plan to redistribute this stuff)
** Set SDK type as '''Full SDK for generated filesystem''' and select the appropriate '''32bit Intel''' for host (our Ubuntu install is 32-bit)
* Select '''X11''' for the user environment
* For the X11 desktop environment, ok to leave it blank

* For ''Additional packages'':
** Under ''Development packages'' select:
*** Perl
*** Toolchain
*** Native (on-target) SDK
*** Native (on-target) Qt Embedded SDK
*** Native (on-target) Qt X11 SDK Development
** Under ''Network related packages'' select:
*** Dropbear SSH server
*** NTPdate
** Under ''Platform specific packages'':
*** ''Texas Instruments OMAP3x/AM3x family'' select:
**** Matrix GUI for QT/X11
**** PowerVR SGX demos for X11
**** PowerVR SGX gfxdriver plugin for QT/X11
**** TI texture streaming demo for X11
*** ''Texas Instruments OMAP3x/DaVinci/OMAPL family (using DSP)'' select:
**** TI DSPLINK Example Applications
**** TI Codec Engine Example Applications
**** Texas Instruments Gstreamer plugins
*** ''Various demonstration configs'' select:
**** Beagleboard validation GNOME image

Now click '''Build Me!''' This will take some time.

The result of the build will be several files. (''MM''=month of creation, ''XXXX''=unique name you provided)
* Angstrom-2011.''MM''-narcissus-beagleboard-i686-''XXXX''-image-sdk.tar.gz image with the SDK
* ''XXXX''-image-beagleboard.tar.gz image with the file system contents.
* ''XXXX''-image-beagleboard-sd-1GiB.img.gz is a 1GB SD card image.
* ''XXXX''-image-beagleboard-sd-4GiB.img.gz is a 4GB SD card image.

Now we need to install the SDK image
<pre>
tar -C ~/toolchains -xzf Angstrom-2011.MM-narcissus-beagleboard-i686-XXXX-image-sdk.tar.gz
</pre>
(again, ''MM''=month of creation)

This will install the toolchain to <code>~/toolchains/usr/local/angstrom/arm</code>. This is a little long so let's move it
<pre>
mv ~/toolchains/usr/local/angstrom/arm ~/toolchains/arm-angstrom
rm -Rf ~/toolchains/usr
</pre>
So now we have the ARM compiler ready to be used. We will use the SD card image later.

== Get ready for DSP Development ==

* Download the latest C6Run release package from [https://gforge.ti.com/gf/project/dspeasy/frs/ here].

* Unzip the C6Run package
<pre>
$ tar -xzf ~/Downloads/C6Run_X_YY_ZZ_WW.tar.gz
</pre>

This will create a directory C6Run_X_YY_ZZ_WW in the current directory (I just use my home directory).

* Download the Texas Instruments C6000 Compiler tools (version 7.2.2 or later) from [https://www-a.ti.com/downloads/sds_support/TICodegenerationTools/download.htm here].
Note that this requires you to have a login with [http://my.ti.com my.ti.com]. This is a little annoying.

*Install the DSP compiler to $(HOME)/toolchains
<pre>
$ mkdir -p ~/toolchains
$ chmod +x ~/Downloads/ti_cgt_c6000_7.2.2_setup_linux_x86.bin
$ ~/Downloads/ti_cgt_c6000_7.2.2_setup_linux_x86.bin --mode silent --installto ~/toolchains
</pre>
This takes a minute and installs silently (you are implicitly agreeing to some EULA when you do this). The DSP toolchain will be in <code>~/toolchains/TI_CGT_C6000_7.2.2</code>.

== Setup c6run ==

* Let's setup up c6Run so we can build DSP code.
** Edit the '''Rules.mak''' to point to the right ARM and DSP toolchains:
<pre>
CODEGEN_INSTALL_DIR ?= $(HOME)/toolchains/TI_CGT_C6000_7.2.2
ARM_TOOLCHAIN_PATH ?= $(HOME)/toolchains/arm-angstrom
ARM_TOOLCHAIN_PREFIX ?= arm-angstrom-linux-gnueabi-
</pre>

It also appears that we need to make sure that the '''LINUXUTILS_VERSION''' is set to '''2_25_05_11'''. Without this, any application built with C6Run won't work on the current 2011.03 build generated by Narcissus since the kernel module inlcuded is based on the older LinuxUtils.

** Now get all dependent components to build back-end libararies. The fetching and install may take some time
<pre>
$ cd ~/C6Run_X_YY_ZZ_WW
$ make get_components
</pre>

** Edit the file '''platforms/beagleboard-xM/platform.mak''' and get rid of the redefines of the ARM_TOOLCHAIN_PATH and ARM_TOOLCHAIN_PREFIX (since we want to use the version we just set above in Rules.mak)

** Select beagleboard-xM config
<pre>
$ make beagleboard-xM_config
</pre>

** build the back-end libraries
<pre>
$ make gpp_libs dsp_libs
</pre>

** Source the environment for the C6Run tools
<pre>
$ source environment.sh
</pre>

** Build all the examples and test cases to make sure things work
<pre>
$ make examples tests
</pre>

If that all worked, then C6Run is ready to be used to build DSP code for use with ARM programs

* Now we can get the Beagle up and running. We will use the XXXX-image-beagleboard-sd-4GiB.img.gz file generated by Narcissus.

=== Older 2010 image ===

# Go to [http://narcissus.angstrom-distribution.org/ here]
# Under '''Select the machine you want to build your rootfs image for:''' select '''beagleboard'''

There are many configurations you can try. For starts try

# Scroll to almost the bottom and select '''Platform specific packages:'''
# Again scroll to near the bottom and select '''Linuxtag 2010 beagleboard demo'''
# Click '''Build me!''' and wait
# Once the image is created, follow the instructions to download the image. It's big so it will take a while

Once the image is build you will have two files to download. One is a disk image of the CD card and the other is the root file system.

# Download both of these
# Run <code>host$ sudo zcat XXX | dd of=/dev/of/your/sd bs=8225280</code>. This will partition and format the SD card and install the files needed to boot Linux. It took me about 3 minutes.
# run <code>host$ sync</sync> to be sure all the files have been written.
# Next, uncompress the root file system image on the CD card. <code>host$ cd /media/rootfs</code>
# <code>host$ tar -xvf ~/Documents/....</code>
# <code>host$ sync</code>

Eject the SD and plug it in your Beagle and power it up.

ECE497 Notes on gpio-keys

2013-05-18T15:59:13Z

Yoder:

[[Category:ECE497Notes |g ]]
{{YoderHead}}

== Timers ==
Here's some leads on using timers.

[https://groups.google.com/forum/?fromgroups#!topic/beagleboard/lCagocQaKiY%5B1-25%5D kunen.org]

== gpio-keys ==
I'm trying to figure out how to access the USER button on the Beagle xM. It looks like the new versions of the SD image use gpio-keys to manage gpio 4 so you can't access it via
beagle$ '''cd /sys/class/gpio'''
beagle$ '''echo 4 > export'''
bash: echo: write error: Device or resource busy

You need to access it via evtest, but I don't see a way to do it via the shell.

=== References ===

* [https://groups.google.com/forum/#!searchin/beagleboard/USER$20button/beagleboard/yqIlD3NTWWE/2Qr_Rzh1IsgJ Here] Jason suggests looking at evtest.c to learn how to access the USER button.

* [http://www.sakoman.com/OMAP/how-to-use-the-buttons-on-omap-development-boards.html Here] are some details on evtest.

{{YoderFoot}}

ECE497 Notes on gpio

2013-05-18T15:58:41Z

Yoder:

[[Category:ECE497Notes |g ]]
{{YoderHead}}

These are notes on how to do gpio faster than the /sys/class/gpio.

== DSP ==
Here are some notes on how to access the gpio pins from the DSP. So far it doesn't read the push button.

[http://e2e.ti.com/support/embedded/bios/f/355/t/62947.aspx Here] is the starting point for this. It appears to be a working example that reads the pushbutton (gpio 4) on the Beagle xM from the DSP.

Everything is in a git repository. [[EBC Exercise 01a Getting Exercise Support Materials | Here]] are notes to how to set it up.

beagle$ '''cd exercises/DSPgpio'''
beagle$ '''ls -F'''
Makefile readPushbuttonViaDSP* readPushbuttonViaDSP.c
beagle$ '''make'''
/opt/toolchains/c6run_binary/bin/c6runapp-cc readPushbuttonViaDSP.c -o readPushbuttonViaDSP
"readPushbuttonViaDSP.c", line 35: warning #225-D: function declared implicitly
"readPushbuttonViaDSP.c", line 46: warning #225-D: function declared implicitly
"readPushbuttonViaDSP.c", line 47: warning #225-D: function declared implicitly
"readPushbuttonViaDSP.c", line 50: warning #225-D: function declared implicitly
"readPushbuttonViaDSP.c", line 52: warning #225-D: function declared implicitly

undefined first referenced
symbol in file
--------- ----------------
_HWI_enableWugen ./readPushbuttonViaDSP.temp.o

error #10234-D: unresolved symbols remain
error #10010: errors encountered during linking;
"readPushbuttonViaDSP.dsp_image.out" not built
make: *** [readPushbuttonViaDSP] Error 1

It appears '''HWI_enableWugen''' isn't defined. Let's comment it out and see what happens.

beagle$ '''make'''
/opt/toolchains/c6run_binary/bin/c6runapp-cc readPushbuttonViaDSP.c -o readPushbuttonViaDSP
"readPushbuttonViaDSP.c", line 35: warning #225-D: function declared implicitly
"readPushbuttonViaDSP.c", line 46: warning #225-D: function declared implicitly
"readPushbuttonViaDSP.c", line 50: warning #225-D: function declared implicitly
"readPushbuttonViaDSP.c", line 52: warning #225-D: function declared implicitly

readPushbuttonViaDSP successfully created

Success, but if you run it, it doesn't respond to the push button.

== mmap ==

* [https://groups.google.com/forum/?fromgroups#!topic/beagleboard/wkv24jV1zw8 Here's] a good discussion with many leads.
* [http://aquaticus.info/beaglebone-web-led Here's] a python lead.
* [http://www.linkedin.com/groups/Building-High-Performance-BeagleBone-GPIO-1474607.S.156569753?qid=262fdaa3-69d7-4f42-9f1a-49e025f9c828&trk=group_most_popular-0-b-ttl&goback=%2Eanb_2693438_*2_*1_*1_*1_*1_*1%2Egmp_1474607 Building a High Performance BeagleBone GPIO library in C] is a lead from LinkedIn.

== PRU ==

* [https://groups.google.com/forum/?fromgroups#!topic/beagleboard/yOa8LrDtG1A%5B1-25%5D This] points to a nice walk through.
* [http://processors.wiki.ti.com/index.php/Category:PRU PRU Wiki]
* [https://github.com/mranostay/beagle-nixie Nixie tube via PRU]
* [https://groups.google.com/forum/?fromgroups=#!topic/beagleboard/eRtL6z_qPAU Spreadsheet for PRU pins]

== Timers ==

* [https://groups.google.com/forum/?fromgroups#!topic/beagleboard/lCagocQaKiY%5B1-25%5D how] to change timer from 100 to 1000.

== SPI ==

* [http://www.eetimes.com/discussion/beginner-s-corner/4023908/Introduction-to-Serial-Peripheral-Interface Introduction to Serial Peripheral Interface] looks like a nice overview.

== ARM MMU ==

* [http://www.embedded-bits.co.uk/2011/mmutheory/#more-705 Turning on an ARM MMU and Living to tell the Tale: Some Theory]

{{YoderFoot}}

ECE497 Notes on DSP via c6run

2013-05-18T15:58:23Z

Yoder:

[[Category:ECE497Notes |c6 ]]

Use [[EBC Exercise 09 Using the DSP for Audio Processing]] instead, though you need to follow these instructions to cross compile c6run.

c6run is an easy way to use the DSP on the BeagleBoard. You can either setup your host computer to cross compile c6run for the Beagle, or compile right on the Beagle. Here's how to do each.

== Setting up cross compiling on a host computer ==
Here are some notes on how to get c6run going on the BeagleBoard. This has been modified to add detail (4/27/2011) for the ECE4356 class.

=== Downloads ===

There are some 350M of files that need to be downloaded and installed to use '''c6run'''. The good news is you don't have to install anything else. The bad news is, if this is being used with a class, 350M * number_of_students can strain a campus internet connection. Therefore we have two options, loading from the internet (works for everyone), and loading from your campus (works if someone on your campus has already downloaded for you).

The files you need to download are:

* C6run_m_yoder.tgz
* ti_cgt_c6000_7.0.4_setup_linux_x86.bin
* angstrom-2010.4-test-20100422-i686-linux-armv7a-linux-gnueabi-toolchain-qte-4.6.2.tar.bz2
* bios_setuplinux_5_41_09_34.bin

'''C6run_m_yoder.tgz''' contains the following:

# /lib/modules from target FS
# uImage itself
# C6Run package prebuilt for the above
# C6Run target software
## Kernel modules for TI components
## loadmodules.sh and unloadmodules.sh
## pre-compiled test and and example applications

Pick your method of getting them.

==== From the Internet ====

* [[Media:C6run_m_yoder.tgz]] comes from the eLinux site.
* Download the TI C6000 v7.0.4 code generation tools for Linux from [https://www-a.ti.com/downloads/sds_support/TICodegenerationTools/download.htm here]
* Download the angstrom ARM toolchain from [http://www.angstrom-distribution.org/toolchains/angstrom-2011.03-i686-linux-armv7a-linux-gnueabi-toolchain-qte-4.6.3.tar.bz2 here]
* Download the 5.41.09.34 DSP/Bios package from [http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/bios/dspbios/5_41_09_34/exports/bios_setuplinux_5_41_09_34.bin here]

==== From your Campus ====

Go to your campus site and look for the files listed above. The following schools have the files:

; Rose-Hulman
: The class dfs site
; UTEP
: EE4356 web site

=== Instructions for Host Setup and Build ===

Now that you have downloaded the above files, here is how to install them. It's assumed that the downloaded files are in your ~/Download directory (note ~ is /home/beagle below).

Now we create the toolchains directory and populate it

* Install the codegen tools to <code>~/toolchains/TI_CGT_C6000_7.04</code> (you implicitly accept a EULA when doing this)
host$ mkdir ~/toolchains
host$ cd ~/Downloads
host$ chmod +x ti_cgt_c6000_7.0.4_setup_linux_x86.bin
host$ ls -l ! Look for an x by ti_... to verify it is executable
host$ ./ti_cgt_c6000_7.0.4_setup_linux_x86.bin --installto ~/toolchains --mode silent

* Install the ARM toolchain
host$ tar -C ~/toolchains -xjf angstrom-2010.4-test-20100422-i686-linux-armv7a-linux-gnueabi-toolchain-qte-4.6.2.tar.bz2

The ARM toolchain will be in <code>~/toolchains/usr/local/angstrom/arm/</code>

* Install the DSP/Bios package (you implicitly accept a EULA when doing this)
host$ chmod +x bios_setuplinux_5_41_09_34.bin
host$ ./bios_setuplinux_5_41_09_34.bin --mode silent --prefix ~/toolchains

* Install the pre-built C6Run package. To do this you must first untar the c6run_m_yoder.tgz file
host$ tar -xvzf c6run_m_yoder.tgz
host$ cd c6run_m_yoder
host$ tar -C ~/toolchains -xzf c6run_0_95_02_02_beagleboard.tar.gz

* Edit the c6run environment settings to correctly point to the location of the components on your host PC (replace ${HOME} with the absolute path)
host$ cd ~/toolchains/c6run_0_95_02_02_beagleboard
host$ vi environment.sh
/* the following command in vi would make the substitution on all cases */
:1,$s/\${HOME}/\/home\/beagle
* We now want to set up our environment variables. But first we will check to see what they are currently.
host$ printenv ! Prints all the environment variables, note too many to see
host$ printenv | more ! Prints out a page at a time, hit space bar to advance
host$ printenv | grep ARM ! Only prints lines that have “ARM” in them
host$ printenv | grep C6 ! Only prints lines that have “C6” in them

* The above commands, unless you ran the <code>environment.sh</code> command previously, should show no environment variables with ARM or C6 in them
* Source the environment variables and rerun the checks
host$ source environment.sh
host$ printenv | grep ARM ! Only prints lines that have “ARM” in them
host$ printenv | grep C6 ! Only prints lines that have “C6” in them

The preceding checks should now show that the following FOUR environment variables are set: ARM_TOOLCHAIN_PREFIX, ARM_TOOLCHAIN_PATH, CFLAGS, and C6RUN_TOOLCHAIN_PATH. At this point the environment and components are all setup to build the examples and test cases included in the the C6Run package. The compilation scripts (c6runlib and c6runapp scripts) rely on these and the other variables from the environment.sh file.

It is suggested that the test and example makefiles be used as a template for any builds done for your own code.

* Run '''make''' to compile the example code
host$ cd example ! You should be in /home/beagle/toolchains/c6run_0_95_02_02_beagleboard/examples
host$ make
* Look at the output to make sure that no errors occurred. If errors occur then either correct them or seek instructor help
* Go into the sub directories to see the compiled code
host$ cd c6runapp/emqbit
host$ ls
* You should see in the directory listing the files bench_arm and bench_dsp (among others).

I added the following lines to my Makefile in the emqbit directory:
<pre>
install:
scp bench_arm bench_dsp cfft_arm cfft_dsp root@beagle:c6run_target/examples/c6runlib/emqbit
</pre>
I can now automatically install on the Beagle by running:
<pre>
host$ make install
</pre>

=== Target Preparation ===

It appears that if you are running a recent image, (from [http://beagleboard-validation.s3.amazonaws.com/deploy/201008201549/sd/list.html here] for example) you don't have to install a new uImage or the modules in /lib/modules. Skip 1 and 2 below and just do 3. If it doesn't work, go back and do 1 and 2 also.

1. Setup the beagleboard to boot using the included kernel image (uImage binary file). This should just require replacing the uImage file on your SD card with the provided one (rename the file to be just 'uImage'). This step can be accomplished with the following commands, after the SD card which has the Angstrom linux system has been put into the card reader and mounted on the host system.
host$ df ! Verify that /media/BEAGLE and /media/ANGSTROM file systems are available
host$ cd /media/BEAGLE ! Or whichever file system has the uImage file
host$ mv uImage uImage.bak ! Save a copy in case you mess up
host$ cd ~/Downloads/C6run_m_yoder
host$ cp uImage /media/BEAGLE

2. Copy the the contents of the provided /lib/modules to the target's /lib/modules path. I (Yoder) found I didn't need to do this. I (Usevitch) concur.

3. Copy the contents of c6run_target.tar.gz to the target file system. I placed it in /opt. It contains the kernel modules from the TI components and the loadmodules.sh script which should be used to install them. The pre-built examples and test cases are also included in this archive. However, we also want to see if our compiled example code will work. Therefore we will copy over our examples directory.
host$ mkdir /media/ANGSTROM/opt
host$ cp c6run_target.tar.gz /media/ANGSTROM/opt
host$ cd /media/ANGSTROM/opt
host$ tar -xvf c6run_target.tgz ! This can be done on the host or on the beagleboard when linux boots
host$ cp -R ~/toolchains/c6run_0_95_02_02_beagleboard/examples . ! copy our examples directory onto the SD card
host$ cd ! can't unmount a file system in use
host$ umount /media/ANGSTROM
host$ umount /media/BEAGLE

=== Target Running ===
* Remove the SD card, place it into the beagleboard, and boot Angstrom linux.
* Before running any c6run based application, make sure you run the loadmodules.sh script to load the needed kernel modules.
beagle$ cd /opt/home/daniel/c6run_target
beagle$ ./unloadmodules.sh ! sometimes modules are left over and need to be removed
beagle$ ./loadmodules.sh
* Now we will run our compiled fft benchmark examples
beagle$ cd /opt/examples/c6runapp/emqbit
beagle$ ./bench_arm
beagle$ ./bench_dsp

== Compiling on the BeagleBoard ==

== Notes on upgrading ==

Here's some of the things I did to upgrade from c6run_0_95_02_02_beagleboard to C6Run_0_97_03_03.

I haven't been successful at this yet.

* Download new version of bios from [http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/bios/index.html here]. I got 5.41.10.36
* Download new 'C6000 code generation tools from [https://www-a.ti.com/downloads/sds_support/TICodegenerationTools/download.htm here]. I got v7.2.2 since that's what the files pointed to. v7.2.4 is the newest, it might work too.
* Copied config.mak from c6run_0_95_02_02_beagleboard to C6Run_0_97_03_03. I fixed the C6RUN_INSTALL_DIR path. <code>C6RUN_INSTALL_DIR=/home/yoder/BeagleBoard/C6Run_0_97_03_03/toolchains</code>

ECE497 Notes on Device Tree

2013-05-18T15:57:25Z

Yoder:

[[Category:ECE497Notes |D ]]
{{YoderHead}}

Here are some things I'm finding on [http://devicetree.org/Device_Tree_Usage Device Tree].

* [http://www.eewiki.net/display/linuxonarm/BeagleBone Robert Nelson BeagleBone]
* [http://www.eewiki.net/display/linuxonarm/BeagleBone+Black Robert Nelson BeagleBone Black]
* [http://hipstercircuits.com/enable-pwm-on-beaglebone-with-device-tree-overlays/ Enable PWM on BeagleBone with Device Tree overlays]

{{YoderFoot}}

ECE497 Notes on Creating a Beaglebone Cape

2013-05-18T15:56:59Z

Yoder:

[[Category:ECE497Notes |C ]]
[[Category:EmbeddedBeagleClass]]

So you are thinking about building a Beaglebone cape? Awesome! There are a lot of reasons to make a cape. In 2012, beagleboard.org and circuitco held a [http://beagleboard.org/capecontest Beagle Cape competition] and gave the top three design entries $1000 dollars plus lifetime royalties on sales of the cape on circuitco. You could also try to get your cape licensed and sold by Adafruit, Sparkfun, or other DIY websites separately. Even if you just interested in a fun DIY project, capes are an awesome way to learn a lot about circuit design and embedded systems. Good Luck!

== Design Decisions ==

The first issue that must be tackled is what exactly you want on your cape. There is a [https://docs.google.com/spreadsheet/ccc?key=0AtD7XdBlve3HdDZqUk0xQ1dpV2NiNm43d0pNWmVGdmc&hl=en_US#gid=0 Google Spreadsheet] that lists most Beaglebone capes that have been completed or are in the process of being completed. If the cape you are building does not have components on it that are in the repository, it is probably time to ask yourself whether the beaglebone supports the hardware you have selected.

Also, if your cape idea is really similar to one in the repository, I wouldn't get too down about it. Paypal is really similar to Google Checkout, Wirecard, and Moneybookers, but continues to be the standout internet money handling service for various reasons. Basically, I would suggest continuing to work on your idea. Especially if it offers something unique that the other solutions in the repository do not include.

When choosing parts that you want on your cape, realize that some parts are easier to put on PCBs than others. Try looking up libraries for the parts you want to use by googling "msp430 allegro library" or "msp430 Eagle library." If there is not library, you will likely have to create a pad and footprint for the part.

== Tools Needed ==
[[File:EagleCadSymbol.png]]

Eagle CAD is an open source schematic layout and PCB editor environment that is used by most of the PCB open source community. You can find the latest version of Eagle [http://www.cadsoftusa.com/download-eagle/?language=en here].

Eagle CAD is a fully featured CAD program that can be had for the low price of $0 as long as you are okay with these limitations:
*The useable board area is limited to 100 x 80 mm (4 x 3.2 inches).
*Only two signal layers can be used (Top and Bottom).
*The schematic editor can only create one sheet.

[[File:Cadence_logo3.gif]]

Cadence Allegro is licensed to the Rose-Hulman, so it is free to Rose students. Allegro is a little bit harder overall to make PCB's in, but it is supported by the ECE department. Ask Dr. Simoni for help on the PCB. He has a website with video tutorials and other walk-throughs to help you with the process. Rose-Hulman licenses it free for use for any current students. It can be downloaded from the DFS folder. The folder also has instructions on how to install it.

Allegro PCB is licensed by the school and used by many professional organizations throughout the world. See Dr. Simoni for advanced help.

== First Step: Prototyping ==

No Beaglebone cape is known to work until all of the suggested components are prototyped together with various development boards and a Beaglebone. Texas Instruments has many development kits listed on their website product pages. For example, if you navigate to the page for a common [http://www.ti.com/product/msp430g2553 MSP430 Processor] you will find on the right side of the page links to evaluation modules, development tools, and other information.

The other place to look for prototyping information is on the product page itself at vendors like Digikey, Mouser, and Allied Electronics. The MSP430 that we just looked at on the TI website can also be found on the [http://www.mouser.com/ProductDetail/Texas-Instruments/MSP430G2553IPW28/?qs=sGAEpiMZZMsuBfEaN9EhVfH4Abelljmf Mouser website] where you can buy it for $2.00. See also that the Mouser website has information such as a datasheet and schematic footprints for the specific product.

After the evaluation modules are ordered, grab your breadboard such as:

[[File:Breadboard.jpg]]

and begin placing components and wiring everything together.

Realize that if you need any help with the power supplies or other aspect of wiring, refer to the datasheets of the parts you are using. For example, the [http://www.ti.com/lit/ds/symlink/msp430g2553.pdf datasheet] for the MSP430 that I mentioned before indicates that it needs a power supply voltage between 2.2 and 3.6. This means that the 3.3V VCC coming out of the Beaglebone would work perfectly in powering the MSP430.

== Building a Schematic ==

After prototyping, you know where each of the wires is to be routed. The next step is to connect all of the components together in your CAD program of choice. There are excellent circuit layout examples to follow in both OrCAD and Eagle. Whichever program you use, a trick you can use is to find capes that use components in them that you are using in your design. Find the capes at the links below and download their respective OrCAD or Eagle files and find pads and footprints for your design. If you do this, make sure to reference the design that you used. Otherwise, pads and footprints can also be found by googling the respective part: "msp430 footprint"

Their are advantages to using OrCAD over Eagle. There are more examples and you can run simulations in PSpice before laying out the board in OrCAD. Rose-Hulman also continues to buy licenses for the complete OrCAD suite.

[[File:EagleCadSymbol.png]]

There are fewer Eagle examples, but a few excellent examples include:
*[http://ioclk.com/wp-content/uploads/2012/11/QiLiCape-ioclk.v01.rar QiLiCape] Credit goes to http://ioclk.com/beagebone-qilicape-a-wireless-power-charger-cape-for-beaglebone/

*The Adafruit prototype board https://github.com/adafruit/Adafruit-BeagleBone-ProtoBoard

[[File:Cadence_logo3.gif]]

Excellent Cadence Examples include:
*[http://beagleboardtoys.info/index.php?title=Main_Page CircuitCo Examples] Most of the capes on this page where designed in OrCAD.

== The Physical Layout ==
Laying out a PCB can be incredibly difficult. Understanding whether you want 1, 2, or 3 layer boards, how thick should the traces be, how close should the components be placed together, and more are often incredibly overwhelming at first. I cannot stress enough how helpful it would be to attend a PCB workshop that Dr. Simoni holds. He usually has at least one a year. If you cannot make it to a workshop, there are still plenty of resources that you can use to quickly design a PCB.
*Ask Dr. Simoni for his PCB videos. They are not operational currently on the internet, but I believe he still has copies of the videos on his computer
*http://www.expresspcb.com/expresspcbhtm/tips.htm has tips on PCB layout. Definitely a must read for any PCB newbie.
*http://www.robotroom.com/PCB-Layout-Tips.html
*http://www.alternatezone.com/electronics/files/PCBDesignTutorialRevA.pdf *****Excellent Tutorial*****

Really the best advice from one Rose student to another is to start asking questions. The lab techs at Rose-Hulman are incredibly helpful if you are respectful. Mark Crosby is the man to ask if you need a PCB printed. After you believe that your circuit is correct, print as many PCBs as needed until it works correctly. Each board that Mark prints is roughly $20. At Rose, you are only able to print a maximum of 2 layers on a board. If you want to print more than that, you will have to send your PCB to a company to get it printed. The cheapest printing that I found in my time at Rose was at 4pcb.com. They can do almost anything and can get the board back to you in as little as 3 days if you pay for the expensive shipping.

ECE497 Notes on BeagleStache

2013-05-18T15:56:33Z

Yoder:

[[Category:ECE497Notes |S ]]

[http://beagleboard.org/project/stache BeagleStache] is a fun demo using [http://opencv.willowgarage.com/wiki/ OpenCV] to detect faces and give them a nice mustache.

== Installation ==

Instructions for installing BeagleStache can be found at the link [http://beagleboard.org/project/stache above]. They are copied here for convenience.

Run the following as root on the BeagleBone:

git clone git://github.com/jadonk/stache
cd stache
make && make install

Now this will install a desktop icon called 'stache.desktop' that runs the shell script '~/stache/runstache'. By default this script will run the Twitter version that requires a Twitter account to be set up. I modified it to bypass that as below:

#!/bin/sh
cd $HOME/stache
./stache

=== How to Run ===

Double click the desktop icon. If you encounter problems, you can make the following modifications to help debugging. In '~/stache/runstache' append a the line '$SHELL'. And in 'stache.desktop' set 'Terminal=true'

== Conclusion ==

This fun little demo highlights the power of the BeagleBone to do real time video processing.

ECE497 Notes on Andriod

2013-05-18T15:55:26Z

Yoder:

[[Category:ECE497Notes |A]]

{{YoderHead}}

This [http://code.google.com/p/rowboat/wiki/JellybeanOnBeaglebone_WithSGX TI site] looks like a good starting point to play with Andriod.

{{YoderFoot}}

ECE497 Notes on TLC5940 16 LED Driver

2013-05-18T15:55:02Z

Yoder: Moving to Notes category

[[Category:ECE497Notes |T]]
{{YoderHead}}

Here are some leads on interfacing the [http://www.ti.com/product/tlc5940 TI TLC5940 16 Channel LED Driver] to a Launchpad.

* [http://www.ti.com/lit/ug/slau144i/slau144i.pdf MSP430x2xx Family User's Guide]
* [http://hackaday.com/2010/08/11/how-to-launchpad-programming-with-linux/ How-to: Launchpad programming with Linux]
* [http://losinggeneration.homelinux.org/2010/07/02/msp430-launchpad-on-linux/ MSP430 Launchpad on Linux]
* [http://blog.hodgepig.org/2010/09/10/575/ Launchpad SPI Explorer]
* [https://sites.google.com/site/artcfox/demystifying-the-tlc5940 Demystifying the TLC5940] has a nice tutorial on building a library for the TLC5940 for the AVR.
* [http://dbindner.freeshell.org/msp430/lcd_spi.html SPI experiments with the MSP430] has some next examples of doing serial via [http://dbindner.freeshell.org/msp430/lcd_spi.html#_spi_communications_with_ktm_s1201_lcd_panel bitbanging] and using the [http://dbindner.freeshell.org/msp430/lcd_spi.html#_usi_spi_communications_with_ea_dogs102_lcd_panel serial port].
* [http://dbindner.freeshell.org/msp430/index.html Don Bindner MSP430 Launchpad] has lots of well documented examples using the Launchpad for various things.
* [http://www.43oh.com/2010/09/launchpad-spi-ninja/ Launchpad SPI Ninja] shows an example using the Launchpad SPI Explorer.
* [http://processors.wiki.ti.com/index.php/Getting_Started_with_the_MSP430_LaunchPad_Workshop Getting Started with the MSP430 LaunchPad Workshop]
* [http://forum.43oh.com/topic/669-interfacing-the-launchpad-with-tlc5940-16-channel-pwm-driver/#entry5694 Interfacing the Launchpad with TLC5940 16-channel PWM driver]

* [http://forum.43oh.com/topic/126-i2c-explorer/#entry3856 i2c Explorer]

{{YoderFoot}}

ECE497 Calendar and Exercises - Fall 2013

2013-05-18T15:53:13Z

Yoder: Updating for Fall 2013

[[Category:ECE497 |Calendar]]
[[Category:BeagleBoard]]
{{YoderHead}}

Here's what you'll need to do for the class. Unless stated otherwise these are individual exercises, not team.

I'm updating this from last year, so be sure to check the year to be sure it's been refreshed. If the background is white, it hasn't been updated.

'''All assignments are due the start of the following week. Initially that is a Thursday!'''

== Week 1 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Assignment Links
|-
| 1-1
| 30-Aug-2012
|
| Introductions, Demos
| Fire up your Beagle and see it work. Do everything in Exercise 09. Due Friday.
'''[[EBC Exercise 01 Start Here]]''' gives an overview of what we'll be doing over the next few days. Start setting up your Linux development computer now. You can do either a native install, or a virtual machine. [[EBC Exercise 06 Notes on VirtualBox | Here]] and [[EBC Exercise 07 Notes on Installing Ubuntu in VMware Player | here]] are some notes in virtual machine installs. They are out of date. Feel free to update them.

I suggest Ubuntu 12.04 LTS. Some of the TI software may require it. I may not be able to help with other versions of distributions.

| [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]]
[[EBC_Exercise_01_Start_Here#The_Linux_host_computer | EBC Exercise 01 Start Here]]

[[EBC Exercise 02 Out-of-the-Box, Bone]]

[[EBC Exercise 09 Working With Open Source]]
|-
| 1-2
| 31
|
| General Purpose IO, LEDs and push buttons.
| Set up a Beagle, demo in class. Get reference manuals and clone git repository.
| [[EBC Exercise 03 Installing a Beagle OS]]

[[EBC Exercise 05 Getting Exercise Support Materials]]

[[EBC Exercise 10 Flashing an LED]]
|-
| 1-3
| 3-Sept-2012
|
| Interrupts and gpio
|
| [[EBC Exercise 08 Installing Development Tools]]

[[EBC Exercise 11 gpio Polling and Interrupts]]
|-
| 1-4
| 4
|
| i2c, git
|
| [[EBC Exercise 16 git]]
|-
|
| "
|
|
| Add your project ideas
| [[ECE497 Project Ideas]]
|}

== Week 2 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 2-1
| 6-Sept
|
| Pulse Width Modulation
|
| [[EBC Exercise 12 I2C]]

[[EBC Exercise 13 Pulse Width Modulation]]
|-
| 2-2
| 7
|
| Lab Time, Mini Project 01
| Measure gpio and pwm with oscilloscope.
| [[EBC Mini Project 01]]
|-
| 2-3
| 10
|
| gdb, Lab Time
|
| [[EBC Exercise 14 gdb Debugging]]
|-
| 2-4
| 11
|
| Lab Time
|
|
|}

== Week 3 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 3-1
| 13
|
| make, Mini Project 02
| Flash ETC 2012 image on SD card for xM
| [[EBC Exercise 15 make]]

[[EBC Mini Project 02]]

[[EBC Exercise 03 Installing a Beagle OS]]
|-
| 3-2
| 14
|
| Advanced Linux Sound Architecture (ALSA)
|
| [[EBC Exercise 17 Using ALSA for Audio Processing]]
|-
| 3-3
| 17
|
| Using the DSP (c6run)
|
| [[EBC Exercise 18 Using the DSP for Audio Processing]]
|-
| 3-4
| 18
|
| Lab Time, Mini Project 1 demo time
|
|
|}

== Week 4 ==

{|style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 4-1
| 20
|
| Video Processing
|
| [[EBC Exercise 19 DSS2 and sysfs]]

[[EBC Exercise 20 The Display SubSystem (DSS)]]
|-
| 4-2
| 21
|
| Lab Time
|
|
|-
| 4-3
| 24
|
| Threads
|
| [[EBC Exercise 21 Running Audio and Video]]
|-
| 4-4
| 25
|
| Lab Time
|
|
|}

== Week 5 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 5-1
| 27-Sept-2012
|
| Graphical Interfaces and node.js
|
|
|-
| 5-2
| 28
|
| Lab Time
|
|
|-
| 5-3
| 1-Oct-2012
| 2.1-2.3.5, 3.2.13
| Booting, Memory Map, Cross-Development, Processor Basics, TI ARM
|
|
|-
| 5-4
| 2
| 4.1-4.3.3
| The Kernel
|
| [[EBC Exercise 22 Cross-Compiling]]
|}

== Week 6 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 6-1
| 4
| 4.4-4.5, 5.1-5.2
| Adding to the Kernel makefile, Kernel Initialization
| Find the Beagle version of Figure 2-5 on page 25. Be sure to find a numeric value for the starting address of the POP SDRAM. Note where you found this information.
| [[EBC Exercise 23 Configuring the Kernel]]
|-
| "
| "
| 5.3-5.6
| Command Line Processing, __setup Macro
| Configuring the Kernel Lab
| [[EBC Exercise 24 Kconfig Edits]]
|-
| 6-2
| 5
|
| Lab Time
|
|
|-
| 6-3
| 8
| 6.1-6.3
| System Initialization
| Project Status Report, update your project status page.
| [[EBC Exercise 21a Boot Sequence]]
[[ECE497 Contributions and Project Status]]
|-
| 6-4
| 9
| 6.4-6.7
| Initial RAM Disk, Using initramfs
|
|
|}

== Week 7 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 7-1
| 15
| 7.1-7.3
| Bootloaders, Das U-Boot
|
| [[EBC Exercise 25 Configuring U-boot]]
|-
| 7-2
| 16
|
| Demo and Work Day
|
|
|-
| 7-3
| 18
| 8.1-8.4
| Device Driver Basics, Driver Methods
|
| [[EBC Exercise 08 Installing Development Tools]]
[[EBC Exercise 26 Device Drivers]]
|-
| 7-4
| 19
| 11.1-11.4
| BusyBox
| In B105
| [[EBC Exercise 27 BusyBox]]

|}

== Week 8 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 8-1
| 22
| [http://gstreamer.freedesktop.org/ GStreamer]
| GStreamer ([http://wiki.oz9aec.net/index.php/Gstreamer_cheat_sheet Cheat Sheet],
[http://www.oz9aec.net/index.php/gstreamer/345-a-weekend-with-gstreamer Weekend with GStreamer])
| Status Report
| [[EBC Exercise 29 GStreamer]] (optional)
|-
| 8-2
| 23
|
|
| Project Time
|
|-
| 8-3
| 25
|
| Remote debugging with gdb, cbrowser/cscope and strace
| Project Time
| [[EBC Exercise 28 Remote gdb and more]] (optional)
|-
| 8-4
| 26
|
| Project Time
|
| [[ECE497 Contributions and Project Status]]
|}

== Week 9 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 9-1
| 29
|
| Project Time all week
|
|
|-
| 9-2
| 30
|
|
|
|
|-
| 9-3
| 1-Nov-2012
|
|
|
|
|-
| 9-4
| 2
|
|
|
|
|}

== Week 10 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 10-1
| 5
|
|
| Project Time all week
|
|-
| 10-2
| 6
|
|
|
|
|-
| 10-3
| 8
|
|
| Meet in B105
|
|-
| 10-4
| 9
|
|
| Demo Time
|
|}

{{YoderFoot}}

ECE497 Calendar and Exercises

2013-05-18T15:50:39Z

Yoder:

[[Category:ECE497Fall2012 |Calendar]]
[[Category:BeagleBoard]]
{{YoderHead}}

Here's what you'll need to do for the class. Unless stated otherwise these are individual exercises, not team.

I'm updating this from last year, so be sure to check the year to be sure it's been refreshed. If the background is white, it hasn't been updated.

'''All assignments are due the start of the following week. Initially that is a Thursday!'''

== Week 1 ==

{| style="color:blue; background-color:#ffffcc;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Assignment Links
|-
| 1-1
| 30-Aug-2012
|
| Introductions, Demos
| Fire up your Beagle and see it work. Do everything in Exercise 09. Due Friday.
'''[[EBC Exercise 01 Start Here]]''' gives an overview of what we'll be doing over the next few days. Start setting up your Linux development computer now. You can do either a native install, or a virtual machine. [[EBC Exercise 06 Notes on VirtualBox | Here]] and [[EBC Exercise 07 Notes on Installing Ubuntu in VMware Player | here]] are some notes in virtual machine installs. They are out of date. Feel free to update them.

I suggest Ubuntu 12.04 LTS. Some of the TI software may require it. I may not be able to help with other versions of distributions.

| [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]]
[[EBC_Exercise_01_Start_Here#The_Linux_host_computer | EBC Exercise 01 Start Here]]

[[EBC Exercise 02 Out-of-the-Box, Bone]]

[[EBC Exercise 09 Working With Open Source]]
|-
| 1-2
| 31
|
| General Purpose IO, LEDs and push buttons.
| Set up a Beagle, demo in class. Get reference manuals and clone git repository.
| [[EBC Exercise 03 Installing a Beagle OS]]

[[EBC Exercise 05 Getting Exercise Support Materials]]

[[EBC Exercise 10 Flashing an LED]]
|-
| 1-3
| 3-Sept-2012
|
| Interrupts and gpio
|
| [[EBC Exercise 08 Installing Development Tools]]

[[EBC Exercise 11 gpio Polling and Interrupts]]
|-
| 1-4
| 4
|
| i2c, git
|
| [[EBC Exercise 16 git]]
|-
|
| "
|
|
| Add your project ideas
| [[ECE497 Project Ideas]]
|}

== Week 2 ==

{| style="color:blue; background-color:#eeffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 2-1
| 6-Sept
|
| Pulse Width Modulation
|
| [[EBC Exercise 12 I2C]]

[[EBC Exercise 13 Pulse Width Modulation]]
|-
| 2-2
| 7
|
| Lab Time, Mini Project 01
| Measure gpio and pwm with oscilloscope.
| [[EBC Mini Project 01]]
|-
| 2-3
| 10
|
| gdb, Lab Time
|
| [[EBC Exercise 14 gdb Debugging]]
|-
| 2-4
| 11
|
| Lab Time
|
|
|}

== Week 3 ==

{| style="color:blue; background-color:#ffaaff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 3-1
| 13
|
| make, Mini Project 02
| Flash ETC 2012 image on SD card for xM
| [[EBC Exercise 15 make]]

[[EBC Mini Project 02]]

[[EBC Exercise 03 Installing a Beagle OS]]
|-
| 3-2
| 14
|
| Advanced Linux Sound Architecture (ALSA)
|
| [[EBC Exercise 17 Using ALSA for Audio Processing]]
|-
| 3-3
| 17
|
| Using the DSP (c6run)
|
| [[EBC Exercise 18 Using the DSP for Audio Processing]]
|-
| 3-4
| 18
|
| Lab Time, Mini Project 1 demo time
|
|
|}

== Week 4 ==

{|style="color:blue; background-color:#ddffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 4-1
| 20
|
| Video Processing
|
| [[EBC Exercise 19 DSS2 and sysfs]]

[[EBC Exercise 20 The Display SubSystem (DSS)]]
|-
| 4-2
| 21
|
| Lab Time
|
|
|-
| 4-3
| 24
|
| Threads
|
| [[EBC Exercise 21 Running Audio and Video]]
|-
| 4-4
| 25
|
| Lab Time
|
|
|}

== Week 5 ==

{| style="color:blue; background-color:#ffffdd;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 5-1
| 27-Sept-2012
|
| Graphical Interfaces and node.js
|
|
|-
| 5-2
| 28
|
| Lab Time
|
|
|-
| 5-3
| 1-Oct-2012
| 2.1-2.3.5, 3.2.13
| Booting, Memory Map, Cross-Development, Processor Basics, TI ARM
|
|
|-
| 5-4
| 2
| 4.1-4.3.3
| The Kernel
|
| [[EBC Exercise 22 Cross-Compiling]]
|}

== Week 6 ==

{| style="color:blue; background-color:#ffddff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 6-1
| 4
| 4.4-4.5, 5.1-5.2
| Adding to the Kernel makefile, Kernel Initialization
| Find the Beagle version of Figure 2-5 on page 25. Be sure to find a numeric value for the starting address of the POP SDRAM. Note where you found this information.
| [[EBC Exercise 23 Configuring the Kernel]]
|-
| "
| "
| 5.3-5.6
| Command Line Processing, __setup Macro
| Configuring the Kernel Lab
| [[EBC Exercise 24 Kconfig Edits]]
|-
| 6-2
| 5
|
| Lab Time
|
|
|-
| 6-3
| 8
| 6.1-6.3
| System Initialization
| Project Status Report, update your project status page.
| [[EBC Exercise 21a Boot Sequence]]
[[ECE497 Contributions and Project Status]]
|-
| 6-4
| 9
| 6.4-6.7
| Initial RAM Disk, Using initramfs
|
|
|}

== Week 7 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 7-1
| 15
| 7.1-7.3
| Bootloaders, Das U-Boot
|
| [[EBC Exercise 25 Configuring U-boot]]
|-
| 7-2
| 16
|
| Demo and Work Day
|
|
|-
| 7-3
| 18
| 8.1-8.4
| Device Driver Basics, Driver Methods
|
| [[EBC Exercise 08 Installing Development Tools]]
[[EBC Exercise 26 Device Drivers]]
|-
| 7-4
| 19
| 11.1-11.4
| BusyBox
| In B105
| [[EBC Exercise 27 BusyBox]]

|}

== Week 8 ==

{| style="color:blue; background-color:#ddffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 8-1
| 22
| [http://gstreamer.freedesktop.org/ GStreamer]
| GStreamer ([http://wiki.oz9aec.net/index.php/Gstreamer_cheat_sheet Cheat Sheet],
[http://www.oz9aec.net/index.php/gstreamer/345-a-weekend-with-gstreamer Weekend with GStreamer])
| Status Report
| [[EBC Exercise 29 GStreamer]] (optional)
|-
| 8-2
| 23
|
|
| Project Time
|
|-
| 8-3
| 25
|
| Remote debugging with gdb, cbrowser/cscope and strace
| Project Time
| [[EBC Exercise 28 Remote gdb and more]] (optional)
|-
| 8-4
| 26
|
| Project Time
|
| [[ECE497 Contributions and Project Status]]
|}

== Week 9 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 9-1
| 29
|
| Project Time all week
|
|
|-
| 9-2
| 30
|
|
|
|
|-
| 9-3
| 1-Nov-2012
|
|
|
|
|-
| 9-4
| 2
|
|
|
|
|}

== Week 10 ==

{| style="color:blue; background-color:#ffffff;" cellpadding="10" cellspacing="0" border="1"
! Day !! Date !! Reading !! Topic !! Exercise !! Links
|-
| 10-1
| 5
|
|
| Project Time all week
|
|-
| 10-2
| 6
|
|
|
|
|-
| 10-3
| 8
|
|
| Meet in B105
|
|-
| 10-4
| 9
|
|
| Demo Time
|
|}

{{YoderFoot}}

ECE497 Contributions and Project Status

2013-05-18T15:49:01Z

Yoder: /* Fall 2013 */ Updated for new quarter

[[Category:ECE497 |Contributions]]
{{YoderHead}}

== Fall 2013 ==

=== Project Status ===

Please edit this page and add your project to this list.
Please make the list alphabetical by family name.

Take a look at what you and others have contributed.

{|
|-
! Name
! Contributions
! Project
! git repository
|-
| [[User:Yoder | Mark A. Yoder]]
| [[Special:Contributions/Yoder | contrib]]
| [[ECE497 Project Template | My Beagle Project]]
| [https://github.com/MarkAYoder MarkAYoder]
|}

== Fall 2012 ==

=== Project Status ===

Please edit this page and add your project to this list.
Please make the list alphabetical by family name.

Take a look at what you and others have contributed.

{|
|-
! Name
! Contributions
! Project
! git repository
|-
| [[User:atniptw | Tom Atnip]]
| [[Special:Contributions/atniptw|contrib]]
| [[ECE497 Beagle VNS | Beagle VNS]]
| [https://github.com/atniptw/ atniptw]
|-
| [[User:jessebrannon | Jesse Brannon]]
| [[Special:Contributions/Jessebrannon|contrib]]
| [[ECE497 Project Rover | Rover]]
| [https://github.com/brannojs/ brannojs]
|-
| [[User:Xinyu1991 | Xinyu Cheng]]
| [[Special:Contributions/Xinyu1991|contrib]]
| [[ECE497_Project:_Kinect | Kinect]]
| [https://github.com/xinyu1991/ Xinyu Cheng]
|-
| [[User:correlbn | Bryan Correll]]
| [[Special:Contributions/correlbn|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/correlbn/My-Beagle-Project/ Correlbn]
|-
| [[User:draneaw | Alex Drane]]
| [[Special:Contributions/draneaw|contrib]]
| [[ECE497: Remote Web Cam Viewer Final Project| Remote Web Cam Viewer]]
| [https://github.com/draneaw/ Draneaw]
|-
| [[User:duganje | Josh Dugan]]
| [[Special:Contributions/duganje|contrib]]
| [[ECE497 Project: XBee|XBee]]
| [https://github.com/duganje/ duganje]
|-
| [[User:Geislekj | Kevin Geisler]]
| [[Special:Contributions/geislekj|contrib]]
| [[ECE497 Beagle VNS | Beagle VNS]]
| [https://github.com/geislekj/ geislekj]
|
|-
| [[User:chris.good | Christopher A Good]]
| [[Special:Contributions/Chris.good|contrib]]
| [[ECE497 Project RoverGUI | RoverGUI]]
| [https://github.com/goodca/ goodca]
|
|-
| [[User:hansenrl | Ross Hansen]]
| [[Special:Contributions/hansenrl|contrib]]
| [[ECE497 Project Rover | Rover]]
| [https://github.com/hansenrl/ Hansenrl]
|
|-
| [[User:jungeml | Michael Junge]]
| [[Special:Contributions/jungeml|contrib]]
| [[ECE497 Project Rover | Rover]]
| [https://github.com/jungeml/ Jungeml]
|-
| [[User:larmorgs | Greg Larmore]]
| [[Special:Contributions/larmorgs|contrib]]
| [[ECE497 SPI Project | SPI Project]]
| [https://github.com/larmorgs Greg Larmore]
|-
| [[User:Lobdeljt | John Lobdell]]
|
| [[ECE 497 lobdeljt Project | My Beagle Project]]
| [https://github.com/jtlobdell jtlobdell]
|-
| [[User:Lix | Xia Li]]
| [[Special:Contributions/Lix|contrib]]
| [[ECE497 Project: Kinect | Kinect]]
| [https://github.com/1984xiali/ xiali]
|-
| [[User:Millerap | Andrew Miller]]
| [[Special:Contributions/Millerap|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/millerap millerap]
|-
| [[User:mmoravec | Matthew Moravec]]
| [[Special:Contributions/mmoravec|contrib]]
| [[ECE497 Project: XBee|XBee]]
| [https://github.com/mmoravec/ mmoravec]
|-
| [[User:ngop | Peter Ngo]]
| [[Special:Contributions/ngop|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/ngop/ ngop]
|-
| [[User:Popenhjc | James Popenhagen]]
| [[Special:Contributions/Popenhjc|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/popenhjc/ popenhjc]
|-
| [[User:Richarsm | Sean Richardson]]
| [[Special:Contributions/Richarsm|contrib]]
| [[ECE497 SPI Project | SPI Project]]
| [https://github.com/seanrich Sean Richardson]
|-
| [[User:shinnsm|Stephen Shinn]]
| [[Special:Contributions/shinnsm|contrib]]
| [[ECE497 Project: XBee|XBee]]
| [https://github.com/shinnsm shinnsm]
|-
| [[User:Whiteer | Elias White]]
|
| [[ECE497 SLAM via ROS | My Beagle Project]]
| [https://github.com/whiteer whiteer]
|-
| [[User:ruff | Ruffin White]]
| [[Special:Contributions/ruff|contrib]]
| [[ECE497 Beagle VNS | Beagle VNS]]
| [https://github.com/ruffsl/ ruffsl]
|-
| [[User:Yoder | Mark A. Yoder]]
| [[Special:Contributions/Yoder | contrib]]
| [[ECE497 Project Template | My Beagle Project]]
| [https://github.com/MarkAYoder MarkAYoder]
|-
| [[User:Astroricks | Yue Zhang]]
| [[Special:Contributions/Astroricks | contrib]]
| [[ECE497_Project:_Kinect | Kinect]]
| [https://github.com/Astroricks/Beagle-Project Yue Zhang]
|}

== Winter 2011-2012 ==

=== Contributions ===

# [[Special:Contributions/Yuming | Yuming Cao]]
# [[Special:Contributions/Yifei | Yifei Li]]
# [[Special:Contributions/Harrisgw | Greg Harrison]]
# [[Special:Contributions/mac | Jack Ma]]
# [[Special:Contributions/Gemini91 | Guanqun Wang]]
# [[Special:Contributions/Yanj | Mona Yan]]
# [[Special:Contributions/Yoder | Mark A. Yoder]]
# [[Special:Contributions/Yuhasmj | Michael Yuhas]]
# [[Special:Contributions/Ziyi Zhang | Ziyi Zhang]]
# [[Special:Contributions/Zitnikdj | David Zitnik]]
# [[Special:Contributions/Zitnikdj | Alex Drane]]
# [[Special:Contributions/jessebrannon | Jesse Brannon]]
# [[Special:Contributions/larmorgs | Greg Larmore]]
# [[Special:Contributions/jungeml | Michael Junge]]
# [[Special:Contributions/millerap | Andrew Miller]]
# [[Special:Contributions/correlbn | Bryan Correll]]

=== Project Status ===

# [[User:Yoder | Mark A. Yoder]], [[ECE497 Project Template | My Beagle Project]]
# [[user:Yanj|Mona Yan]] and [[user:Harrisgw| Greg Harrison]], [[PS EYE QT PROJECT | Playstation Eye Audio with Qt]]
# [[user:Caogecym | Yuming Cao]] and [[user:Ziyi Zhang | Ziyi Zhang]], [[Node.js Weather Station]]
# [[user:Yifei| Yifei Li]] and [[user:Gemini91| Guanqun Wang]], [[ Kinect Project | Play games using Kinect on Beagleboard]]
# [[user:Yuhasmj| Michael J. Yuhas]] and [[user:mac | Jack Ma]], [[ Multiple Partitions via U-boot | Multiple Partitions via U-boot ]]
# [[user:Zitnikdj| David Zitnik]], [[ ECE497 Project: Twitter Java Application | Twitter Java Application ]]

{{YoderFoot}}

BeagleBoard Hardware Interfacing

2013-05-18T15:46:15Z

Yoder:

[[Category:BeagleBoard]]
[[Category:ECE597]]

This page is meant to help anyone who wants to create an expansion board to interface with the [[BeagleBoard]]. It summarizes some of the commercial options, and includes some recommendations for components for a custom board.

= Commercial Options =
There are several commercial boards that may work without the need to create a custom board.

* [[BeagleBoard_Zippy]]
* [[BeagleBoard_Zippy2]]
* [[BeagleBoard_Trainer]]

A few more options can be found [[BeagleBoard#Expansion_boards|here]].

= General Notes =
== 1.8V I/O ==
It is very important to remember that the I/O on the BeagleBoard is 1.8V. Level shifting must occur to interface with 3.3V or 5V devices. This is very important as these voltages will easily break pins on the BeagleBoard.

== Powering the Beagle ==
The BeagleBoard is typically powered through the barrel connector or the MiniUSB connector. When adding an expansion board, the option is available to power the BeagleBoard from a power supply on that expansion board. The 5V pin on the expansion connector is connected to the barrel connector directly. This means that you can power the board from either one, and pass 5V through to the other. An elegant solution is to place a switcher on the expansion board to provide 5V to the BeagleBoard and any external 5V devices. This allows you to use a wide range of power supplies or wall warts while providing clean, safe 5V DC to the BeagleBoard. One simple switcher to take a look at is the TPS54x0 series (the x indicates the maximum current output; 1A, 2A, 3A, and 5A devices are available).

== Expansion Connectors ==
There are several expansion connectors available on the BeagleBoard, depending on the revision. All revisions have J3, a 0.1" spaced header. This is not populated by default, it is left up the user to decide which gender header is desired, and where is should be placed. There have been some indications that newer versions of the BeagleBoard will come populated with a female header oriented facing downward. It may be wise to design with this decision in mind to allow for future expandability when new revisions of the BeagleBoard are released.

There are two other headers available (J4 and J5). These are 0.05" spaced headers, and are usually used only for interfacing with and external LCD. Pins and connectors are more difficult to find for these headers, so it is probably best to stick with using the main expansion header unless these signals or the additional I/O are required.

= Level Shifting =
There are several options for level shifting to use 3.3V or 5V devices.

== MAX3378 ==
The MAX3378 is a quad-input 16MBps bidirectional level shifter. It works well with I2C or GPIO. Many of the commercial expansion boards use these for level shifting. They are only available in a small TSSOP surface mount package, making it difficult to use on a breadboard or some milled boards.

== Single MOSFET Bidirectional Level Shifter ==
See NXP's Appnote [http://ics.nxp.com/support/documents/interface/pdf/an97055.pdf] for more information on this method. BSS88 and BSS138 MOSFETs appear to be compatible with the BeagleBoard and this design. This has not been tested with the BeagleBoard, so be sure to research this option fully before implementing it.

= I2C Devices =
Some general information about I2C and a few compatible devices can be found on [[Interfacing_with_I2C_Devices|Interfacing with I2C Devices]]. Several devices listed at the bottom of the page are confirmed to work with the BeagleBoard. Note that almost any 100kHz or 400kHz I2C device will work with the BeagleBoard, it is just a matter of determining the correct address and registers on the device to read from or write to.

= PCB Tips =
== OrCAD ==
If you are using OrCAD to layout an expansion board, it is extremely useful to use a DXF file to align the mounting holes and the expansion headers. 0.156" holes should be used for the mounting holes. This can be done by exporting the pertinent details from the OrCAD .brd file available in the Design Documents section of the BeagleBoard site. Alternatively, a version that should be compatible with C3 and C4 can be found here: [[File:BeagleBoard.dxf]]. Make sure to check that pin 1 is aligned with pin 1 on the BeagleBoard. This will not be the case by default; a new footprint will need to be created or the connector will need to be "placed" on the bottom of the board.

== Eagle ==
If you make an expansion board using Eagle, you can import DXF or GERBER files using [http://www.cadsoft.de/cgi-bin/download.pl?page=/home/cadsoft/html_public/download.htm.en&dir=eagle/userfiles/misc Eagle PCB Power Tools] from Cadsoft website. It is a freeware that create a script .SCR file from your DXF or GERBER. But there is a limitation in the number of script instructions created so for importing BeagleBoard footprint you will first to select in the DXF or Gerber files what you really want.

== References ==
* [[Media:I2C_PWM_Hardware.pdf|Presentation on I2C, PWM and Hardware interfacing with the BeagleBoard]]

BeagleBoard Hardware Interfacing

2013-05-18T15:45:09Z

Yoder:

[[Category:BeagleBoard]]
[[Category:ECE497]]

This page is meant to help anyone who wants to create an expansion board to interface with the [[BeagleBoard]]. It summarizes some of the commercial options, and includes some recommendations for components for a custom board.

= Commercial Options =
There are several commercial boards that may work without the need to create a custom board.

* [[BeagleBoard_Zippy]]
* [[BeagleBoard_Zippy2]]
* [[BeagleBoard_Trainer]]

A few more options can be found [[BeagleBoard#Expansion_boards|here]].

= General Notes =
== 1.8V I/O ==
It is very important to remember that the I/O on the BeagleBoard is 1.8V. Level shifting must occur to interface with 3.3V or 5V devices. This is very important as these voltages will easily break pins on the BeagleBoard.

== Powering the Beagle ==
The BeagleBoard is typically powered through the barrel connector or the MiniUSB connector. When adding an expansion board, the option is available to power the BeagleBoard from a power supply on that expansion board. The 5V pin on the expansion connector is connected to the barrel connector directly. This means that you can power the board from either one, and pass 5V through to the other. An elegant solution is to place a switcher on the expansion board to provide 5V to the BeagleBoard and any external 5V devices. This allows you to use a wide range of power supplies or wall warts while providing clean, safe 5V DC to the BeagleBoard. One simple switcher to take a look at is the TPS54x0 series (the x indicates the maximum current output; 1A, 2A, 3A, and 5A devices are available).

== Expansion Connectors ==
There are several expansion connectors available on the BeagleBoard, depending on the revision. All revisions have J3, a 0.1" spaced header. This is not populated by default, it is left up the user to decide which gender header is desired, and where is should be placed. There have been some indications that newer versions of the BeagleBoard will come populated with a female header oriented facing downward. It may be wise to design with this decision in mind to allow for future expandability when new revisions of the BeagleBoard are released.

There are two other headers available (J4 and J5). These are 0.05" spaced headers, and are usually used only for interfacing with and external LCD. Pins and connectors are more difficult to find for these headers, so it is probably best to stick with using the main expansion header unless these signals or the additional I/O are required.

= Level Shifting =
There are several options for level shifting to use 3.3V or 5V devices.

== MAX3378 ==
The MAX3378 is a quad-input 16MBps bidirectional level shifter. It works well with I2C or GPIO. Many of the commercial expansion boards use these for level shifting. They are only available in a small TSSOP surface mount package, making it difficult to use on a breadboard or some milled boards.

== Single MOSFET Bidirectional Level Shifter ==
See NXP's Appnote [http://ics.nxp.com/support/documents/interface/pdf/an97055.pdf] for more information on this method. BSS88 and BSS138 MOSFETs appear to be compatible with the BeagleBoard and this design. This has not been tested with the BeagleBoard, so be sure to research this option fully before implementing it.

= I2C Devices =
Some general information about I2C and a few compatible devices can be found on [[Interfacing_with_I2C_Devices|Interfacing with I2C Devices]]. Several devices listed at the bottom of the page are confirmed to work with the BeagleBoard. Note that almost any 100kHz or 400kHz I2C device will work with the BeagleBoard, it is just a matter of determining the correct address and registers on the device to read from or write to.

= PCB Tips =
== OrCAD ==
If you are using OrCAD to layout an expansion board, it is extremely useful to use a DXF file to align the mounting holes and the expansion headers. 0.156" holes should be used for the mounting holes. This can be done by exporting the pertinent details from the OrCAD .brd file available in the Design Documents section of the BeagleBoard site. Alternatively, a version that should be compatible with C3 and C4 can be found here: [[File:BeagleBoard.dxf]]. Make sure to check that pin 1 is aligned with pin 1 on the BeagleBoard. This will not be the case by default; a new footprint will need to be created or the connector will need to be "placed" on the bottom of the board.

== Eagle ==
If you make an expansion board using Eagle, you can import DXF or GERBER files using [http://www.cadsoft.de/cgi-bin/download.pl?page=/home/cadsoft/html_public/download.htm.en&dir=eagle/userfiles/misc Eagle PCB Power Tools] from Cadsoft website. It is a freeware that create a script .SCR file from your DXF or GERBER. But there is a limitation in the number of script instructions created so for importing BeagleBoard footprint you will first to select in the DXF or Gerber files what you really want.

== References ==
* [[Media:I2C_PWM_Hardware.pdf|Presentation on I2C, PWM and Hardware interfacing with the BeagleBoard]]

BeagleBrick

2013-05-18T15:43:54Z

Yoder:

[[Category:ECE497Winter1112]]
[[Category:BeagleBoard]]

The BeagleBrick is a handheld software defined radio integrating the [[BeagleBoard]] with Angstrom Linux, SoftRock 6.3 transceiver, and an LCD touchscreen into an all-in-one radio unit. It's goal is to be an easy to use "iPad for hams."

= Current Status =
The project is currently in a transitional period. This page will document our progress on interfacing with hardware using the BeagleBoard and Linux. More information can be found [http://www.rarcpio.net/beaglebrick/ here].

= Preparing the OS =

== SD Card Setup ==
First, follow the [[BeagleBoardBeginners#SD_card_setup]] guide in formatting your SD card.

Next, on the first partition, copy these files in '''this order'''.
# MLO
# u-boot
# [http://mumon.us/beaglebrick/uImage.beaglebrick uImage]

== Kernel Source ==
We used Git for tracking changes that were made to the kernel source. This git repository can be accessed [https://phire.org/git/?p=linux-omap-2.6;a=shortlog;h=refs/heads/beaglebrick here].

For those not comfortable with Git, a tarball of the complete, configured kernel source can be downloaded [https://phire.org/beaglebrick/linux-2.6-beaglebrick.tar.gz]. This can be built with a simple "make uImage".

== Root File System ==
The ext2 partition on the SD card contains the file system for Linux, where all your regular programs and data reside. There are three options for getting this:

# Our complete filesystem with FLDigi and hamlib configured [http://mumon.us/beaglebrick/beaglebrick.rootfs.tgz is available here].
# You can also compile a distribution remotely from [http://www.angstrom-distribution.org/narcissus/ the Angstrom site]. This has FLDigi, but you will need to add the BeagleBrick's hamlib module.
# Finally, you can create the rootfs yourself, by following [[ECE497_Lab02_Installing_The_Angstrom_Distribution_Old]] This is much more involved than the previous two methods.

== Hamlib ==
We created a new back-end module for hamlib which controlled the tuning, filter switching, and push-to-talk functionality of the BeagleBrick. Again, Git was used to track these changes, and the git repository can be found [https://phire.org/git/?p=hamlib;a=shortlog;h=refs/heads/beaglebrick here]. A tarball of hamlib, including our modifications, can also be downloaded [https://phire.org/beaglebrick/hamlib-beaglebrick.tar.gz].

BeagleBoardPWM

2013-05-18T15:42:44Z

Yoder: Moved to ECE597

[[Category:BeagleBoard]]
[[Category:ECE597]]
[[Category:Robotics]]

There are three pins capable of [http://en.wikipedia.org/wiki/Pulse-width_modulation PWM (pulse-width modulation)] exposed on the C3/C4 BeagleBoard expansion header. PWM is useful for control of a number of devices, from LEDs (which can be faded smoothly with PWM) to [[ECE597 Project Sumo Robot | DC motors]]. For robotics, this means that three hobby servos can easily be controlled by the Beagle given nothing more than a simple [[BeagleBoard_Hardware_Interfacing#Level_Shifting | level-shifting]] circuit, with no CPU usage to speak of.

Alternative approaches are possible. [http://github.com/tallakt/servodrive servodrive] is a kernel module that emits servo control PWM using straight GPIO (this page also claims that straight 1.8 V from the Beagle is sufficient to control servos). [http://thoughtshubham.blogspot.com/2010/04/pwm-generation-in-beagleboard.html This page] shows how to use threading and GPIO to accomplish PWM in userspace. The rest of this page focuses on use of the OMAP's hardware PWM capabilities.

== OMAP Mux Configuration ==

Because the PWM pins are not set as such by default, the OMAP's mux must be configured to expose them before they can be used. See [[BeagleBoardPinMux]] for more details on this procedure. The short version is to add the following lines to the definition of <code>board_mux[]</code> in arch/arm/mach-omap2/board-omap3beagle.c (this has been tested with the 2.6.33 OMAP branch of the kernel).

OMAP3_MUX(DSS_DATA15, OMAP_MUX_MODE2|OMAP_PIN_OUTPUT), /* GPT9_PWMEVT, ball AB26, ex pin 4 */
OMAP3_MUX(UART2_TX, OMAP_MUX_MODE2|OMAP_PIN_OUTPUT), /* GPT11_PWMEVT, ball AA25, ex pin 6 */
OMAP3_MUX(UART2_RTS, OMAP_MUX_MODE2|OMAP_PIN_OUTPUT), /* GTP10_PWMEVT, ball AB25, ex pin 10 */

Obviously these lines should precede the line terminating the array. This will likely be in a block conditional on CONFIG_OMAP_MUX, so you need to have the CONFIG_OMAP_MUX option set in your kernel config.

Note: Setting the kernel config option CONFIG_OMAP_RESET_CLOCKS to yes [[http://github.com/scottellis/omap3-pwm/blob/master/README | may cause problems]].

=== The 2.6.32 kernel ===

I found the above didn't work with the 2.6.32 kernel, rather the MUXing had to be done in u-boot. [[BeagleBoardPinMux#Setting_Mux_Through_u-boot | Here]] is a nice description of how it is done.

== Activating PWM via Timer Registers ==

PWM output on the BeagleBoard is done via the OMAP processor's general-purpose timer mechanism, described in the OMAP35x TRM in section 16.2.4 (page 2546, or page 2698 of the DM3730 TRM). To briefly summarize this (and simplify significantly), the general-purpose timer is a continuously-incrementing counter that can be configured to toggle the PWM output high when a certain value is reached, and low when it overflows. By adjusting the first number the duty cycle can be set. Setting the value the counter starts at can be used to set the frequency of the PWM.

[[File:OMAP3-GPTimer-PWM.svg|thumb|right|300 px|alt="The registers TCRR, TLDR, and TMAR are illustrated as boxes partially-filled from the right. Lines at the value of TLDR, the value of TMAR, and the end are labeled 'Start', 'Match', and 'Overflow' respectively."]]

[[File:OMAP3-GPTimer-PWM-Waveform.svg|frameless|500 px|alt="A square waveform starting at 0, with the beginning labeled as 'Start'. Where the waveform goes to 1 it is labeled 'Match', and when it returns to zero it is labeled 'Overflow, Start'. It then repeats."]]

Each GP timer has a 4K block for memory-mapped registers (see TRM Table 16-12, page 2558 OMAP3530 or page 2710 DM3730). The start addresses of these blocks for the timers on the BeagleBoard are listed below.

{|border=1
|+ BeagleBoard C3/C4 GP Timer Base Addresses
|-
| '''Timer''' || '''Base address''' || '''Expansion header pin'''
|-
| GPTIMER9 || 0x4904 0000 || 4
|-
| GPTIMER10 || 0x4808 6000 || 6
|-
| GPTIMER11 || 0x4808 8000 || 10
|}

These are the registers relevant to our purpose:

{|border=1
|+ BeagleBoard C3/C4 GP Timer Registers
|-
| '''Name''' || '''TRM section''' || '''Offset'''
| '''Description'''
|-
| TCLR || 16.3.2.6 (p. 2568/2719) || 0x024
| Control register.
|-
| TCRR || 16.3.2.7 (p. 2570/2721) || 0x028
| The counter. Increments with the clock when the timer is running.
|-
| TLDR || 16.3.2.8 (p. 2571/2722) || 0x02c
| Timer load register. Holds the value assumed by TCRR when it overflows.
|-
| TMAR || 16.3.2.11 (p. 2575/2725) || 0x038
| Value to be compared with the counter.
|}





== Interacting with Timer Registers in Linux ==

The best way to interact with the timer registers is to use the [[BeagleBoard/GSoC/2010_Projects/Pulse_Width_Modulation | kernel module]] in development as a Google Summer of Code project (this driver is currently, as of July 2010, in development).

Historically interaction with the registers could be done via the special device <code>/dev/mem</code>. This file contains a live view of the contents of physical memory --- meaning that reading and writing to the physical address of a timer register as an offset in <code>/dev/mem</code> reflects the actual thing.

There is one complication, though, in that reads and writes to the OMAP registers cannot be done with byte-oriented I/O (such as the <code>write()</code> system call); however, this can be worked around by using the <code>mmap()</code> syscall. This means that a pointer to a register can be cast to <code>volatile uint32_t*</code> and function correctly.

== OMAP3530 PWM library ==

There is a small library available to simplify manipulating the timer registers via <code>/dev/mem</code>. It is made available under the LGPL 2.1 or MIT license.

Download:
* [http://www.rose-hulman.edu/~mosttw/omap3530-pwm-1.1.tar.gz omap3530-pwm-1.1.tar.gz] (LGPL/MIT, md5 b33232531321778eadc022fef9cf7bac)
* [http://www.rose-hulman.edu/~mosttw/omap3530-pwm-1.0.tar.gz omap3530-pwm-1.0.tar.gz] (LGPL only, md5 ff77617cf07450be1444019809c75a0c)

(These links appear to be broken now. You can get to a version of the PWM code by following the instructions [[EBC Exercise 01a Getting Exercise Support Materials | here]]. It describes how to load code from [https://github.com/MarkAYoder/BeagleBoard-exercises git@github.com:MarkAYoder/BeagleBoard-exercises.git] which contains the pwm code.)

Information regarding compilation of this program is not included in any README file so to ease compilation problems use the following. Keep in mind this has been only tested when compiled on the beagleboard and not cross-compiled though it should still shed light if you have problems.

<pre>
root@beagleboard:~# gcc *.c -o pwm-demo -lglib-2.0 -I/usr/include/glib-2.0
-I/usr/lib/glib-2.0/include
</pre>

When you run your code you may encounter the following error:

<pre>
root@beagleboard:~# ./pwm-demo
0
Bus error
root@beagleboard:~# dmesg | tail -1
[ 174.893035] Unhandled fault: external abort on non-linefetch (0x1818) at 0x4001e024
</pre>

This is caused because the library does not enable the PWM clocks and you are not allowed to access them until this is done. In order to fix this you need to recompile your kernel with the option CONFIG_OMAP_RESET_CLOCKS disabled. More information can be found in this thread:
http://groups.google.com/group/beagleboard/browse_thread/thread/ee42e5c59edf83cd/67be50968de6a9f2?lnk=gst&q=guint8#67be50968de6a9f2

or see the note above at: http://elinux.org/BeagleBoardPWM#OMAP_Mux_Configuration

=== Example usage ===

<pre>
#include <glib.h>
#include <errno.h>
#include "omap3530-pwm.h"

int main(int argc, char **argv) {
int mem_fd = pwm_open_devmem();
if (mem_fd == -1) {
g_error("Unable to open /dev/mem, are you root?: %s", g_strerror(errno));
}
// Set instances 10 and 11 to use the 13 Mhz clock
pwm_config_clock(mem_fd, TRUE, TRUE);
guint8 *gpt10 = pwm_mmap_instance(mem_fd, 10);
// Get the resolution for 20 kHz PWM
guint32 resolution = pwm_calc_resolution(20000, PWM_FREQUENCY_13MHZ);
// Set to half duty cycle
pwm_config_timer(gpt10, resolution, 0.5);
pwm_munmap_instance(gpt10);
pwm_close_devmem(mem_fd);
}
</pre>

== Links and References ==

* [http://www.jumpnowtek.com/index.php?option=com_content&view=article&id=56&Itemid=63 PWM from an OMAP3 Linux System], Scott Ellis ([http://github.com/scottellis/omap3-pwm kernel module])
* [[BeagleBoard/GSoC/2010_Projects/Pulse_Width_Modulation | 2010 GSoC Project: PWM driver]]
* <code>man 2 mmap</code>
* <code>man 2 open</code>
* [http://focus.ti.com/docs/prod/folders/print/omap3530.html OMAP 3530 Technical Reference Manaul]
* [http://beagleboard.org/static/BBSRM_latest.pdf BeagleBoard System Reference Manaul]
* [[Media:I2C_PWM_Hardware.pdf|Presentation on I2C, PWM and Hardware interfacing with the BeagleBoard]]
* [[ECE597 Project Sumo Robot | Project: Sumo Robot]] -- uses PWM to control drive motors via L298 motor drivers.

BeagleBoard Education Workshops

2013-05-18T15:32:02Z

Yoder: /* 2012 ASEE Workshop */

[[Category:ECE497 |W]]
[[Category:BeagleBoard]]
[[Category:Workshops]]
[[Category:Education]]
{{YoderHead}}

== 2013 ASEE Workshop ==
{|
| '''Title:'''
| U216·WORKSHOP: BeagleBone - A Hands-on Workshop
|-
| '''Presentors:'''
| Dr. Steven F Barrett P.E., Jason Kridner, Mark A. Yoder
|-
| '''Location:'''
| Atlanta, Omni CNN Center Hotel, Omni - Chestnut
|-
| '''Date:'''
| 23-June-2013
|-
| '''Link'''
| [http://www.asee.org/public/conferences/20/registration/view_session?session_id=2420 ASEE site]
|}

=== Abstract:===

'''Ticketed event: $100.00 advanced registration and $110.00 on site registration'''

BeagleBone is a low cost, open hardware computer first introduced in November 2011 by BeagleBoard.org, a community of developers sponsored by Texas Instruments. BeagleBone hosts a powerful 32-bit, super-scalar ARM Cortex A8 processor operating at 720 MHz. Yet it is small enough to fit in an Altoids mint tin box. The "Bone'' may be used in a wide variety of projects from middle school science fair projects to senior design projects to first prototypes of very complex systems. Novice users may access the power of the Bone through the user-friendly Bonescript environment. Seasoned users may take full advantage of the Bone's power using the underlying Linux-based operating system, a host of feature extension boards (Capes) and a wide variety of open source libraries. This hands on workshop provides an introduction to this powerful computer and has been designed for a wide variety of users including the first time novice through the seasoned embedded system design professional.

Workshop participants will receive a BeagleBone board and also a BeagleBone book courtesy of BeagleBoard.org and Morgan and Claypool Publishers. This workshop is subsidized by Texas Instruments (TI).

=== Pre Workshop ===

=== Labs ===

=== Post Workshop ===

== 2012 Engibous Summit Workshop ==
{|
| '''Title:'''
| Hands-on workshop on Embedded Linux on BeagleBone
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Dallas
|-
| '''Date:'''
| 30-July-2012
|-
| '''Link'''
| [http://www.ti.com/corp/docs/landing/universityprogram/prize.htm Engibous Summit]
|}

=== Abstract:===

???

=== Pre Workshop ===

You will be mailed some information about the workshop and some things for you to do before arriving.

--Mark

=== Labs ===

=== Post Workshop ===

== 2012 Chandigarh Workshop ==
{|
| '''Title:'''
| Hands-on workshop on Embedded Linux on Beagleboard
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| [http://www.uniti.in/events/venueevents/73-chitkara-school-of-engineering-a-technology Chitkara School of Engineering & Technology] - Chandigarh, India
|-
| '''Date:'''
| 18-20 June-2012
|-
| '''Link'''
| [http://www.uniti.in/events/details/128-hands-on-workshop-on-embedded-linux-on-beagleboard http://www.uniti.in/events/details/128-hands-on-workshop-on-embedded-linux-on-beagleboard]
|}

=== Abstract:===

Beagleboard is a low-cost open-source embedded system development platform. It is based on Texas Instruments DM3730 processor, which includes an on-chip ARM Cortex-A8 processor core, a Texas Instruments C6x DSP core, and a host of peripherals. Beagleboard is a single board computer, which provides adequate performance to run Linux software, yet has a power consumption lower than 2W. A large number of embedded applications have been developed on Beagleboard ([http://www.beagleboard.org www.beagleboard.org]) Module A provides a gentle introduction to the subject of Embedded Linux, Linux Systems Programming and Linux Kernel Programming. The intention of Module B is to provide a hands-on exposure to running Embedded Linux operating system on the Beagleboard and develop system software on the Beagleboard.
=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]].
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|}

=== Labs ===

=== Post Workshop ===

== 2012 Hyderabad Workshop ==
{|
| '''Title:'''
| Three-day workshop on Embedded Linux on Beagleboard
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| [http://www.uniti.in/events/venueevents/69-c-dac-hyderabad C-DAC Hyderabad] - Hyderabad, India
|-
| '''Date:'''
| 14-16 June-2012
|-
| '''Link'''
| [http://www.uniti.in/events/details/123-three-day-workshop-on-embedded-linux-on-beagleboard http://www.uniti.in/events/details/123-three-day-workshop-on-embedded-linux-on-beagleboard]
|}

=== Abstract:===

Linux, which is an “open source” operating system and enjoys considerable popularity on general-purpose computers, is becoming popular in the embedded world also. Different versions and variants of Linux are now available on embedded platforms. In this workshop, the intention is to provide a hands-on introduction to concepts of Linux Systems/Kernel Programming and Embedded Linux

=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]].
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|}

=== Labs ===

=== Post Workshop ===

== 2012 Bangalore Workshop ==
{|
| '''Title:'''
| 6-day modular workshop on Embedded Linux
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| [http://www.uniti.in/events/venueevents/68-cambridge-institute-of-technology Cambridge Institute of Technology] - Bangalore, India
|-
| '''Date:'''
| 11-13 June-2012
|-
| '''Link'''
| [http://www.uniti.in/events/details/122-6-day-modular-workshop-on-embedded-linux www.uniti.in/events/details/122-6-day-modular-workshop-on-embedded-linux]
|}

=== Abstract:===

'''Module A''' provides an overview of basic concepts of Linux, Linux Systems Programming, Linux Kernel Programming, and Embedded Systems. Module A will also include an introduction to Beagleboard, an open-source, low-cost, low-power embedded system development platform. '''Module A''' will be conducted jointly by a team of experts from industry and academia. In '''Module B''', aspects of Embedded Linux on Beagleboard will be explored in greater depth. Module B will be conducted by Prof. Mark A. Yoder of Rose-Hulman Institute of Technology, USA.

=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]].
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|}

=== Labs ===

=== Post Workshop ===

== 2011 FIE Workshop - Cancelled ==
{|
| '''Title:'''
| From DSP Chips to Embedded Processors for Teaching Digital Signal Processing
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Holiday Inn Salon F, Rapid City, South Dakota
|-
| '''Date:'''
| Wednesday, October 12, 2011, 2:30 p.m. - 5:30 p.m
|-
| '''Link'''
| [http://fie-conference.org/fie2011/] [http://fie-conference.org/fie2011/Pages/workshops.htm#SCRL6]
|}

=== Abstract:===

The goal of this hands-on tutorial is to present ideas on how to use Texas Instrument’s DM 3730-based BeagleBoard xM ([www.BeagleBoard.org www.BeagleBoard.org]) for teaching embedded processing using Open Source resources. The DM 3730 is a dual core processor with an ARM Cortex-a8 core and a TI ‘c64x DSP core. The BeagleBoard is Open Source hardware that has sold over 30,000 units since its introduction less than 2 years ago and has a thriving Open Source Software community.

The BeagleBoard has many uses in the classroom. This workshop will show some of those uses and present some of the challenges in teaching with Open Source.

The workshop activities will include:

* several hands-on exercises to get participants familiar with using the Beagle, and how it differs from a traditional 8- or 16-bit microcomputer.
* several demonstrations of what the Beagle can do, such as streaming video and programming its DSP and discussions of what topics to include in an embedded/DSP class including dealing with open source comminutes.
* This workshop is targeted to those who are teaching embedded processors or DSP hardware. Some Linux background would be helpful, but not required. Those with little or no Linux experience will be paired with those with more experience.

=== Post Workshop ===

Even though the workshop has been cancelled, you can still do the exercises. Here ([[Getting a Workshop SD Image]]) are instructions on how to put the tutorial image on your SD card.

Here ([[EBC Embedded Beagle Class Topics]]) is a list of topics I cover in my class. If you have questions, please email me.

== 2011 IEEE ICASSP Workshop ==
{|
| '''Title:'''
| How 32-bit Embedded Processors Change the Focus in Teaching DSP Hardware
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Prague, Czech Republic
|-
| '''Date:'''
| Monday May 23rd, 2011, Afternoon
|-
| '''Link'''
| [http://www.icassp2011.com/en/registration]
|}

=== Abstract:===
This hands-on tutorial presents ideas on how to use TI’s OMAP 3530-based BeagleBoard (www.BeagleBoard.org) for teaching embedded media processing using Open Source resources. The BeagleBoard is Open Source hardware that has sold over 20,000 units since its introduction less than 2 years ago and has a thriving Open Source Software community.
After the introduction, this workshop will complement the Sunday afternoon tutorial “From DSP Chips to Embedded Processors for Teaching Digital Signal Processing”. The Sunday workshop examples focus on programming the ‘C64 DSP on the OMAP3530. This workshop will focus on using Open Source software for media processing (such as GStreamer, OpenCV, etc.) and using the OMAP display subsystem for handling video.
The workshop activities will include:
# Several hands-on exercises to get participants familiar with using the Beagle, (same as tutorial)
# Several demonstrations of what the Beagle can do using Open Source software, including using the display subsystem, recognizing speech, computer vision
# Discussions of what topics to include in an embedded Linux class.
No BeagleBoards will given out.

=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]]. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|-
|Melani Plett
|Seattle Pacific University,
Seattle, Washington, USA
|I teach an undergraduate signals and systems course. I have no Linux experience, though I did use Unix years ago.
|I am thinking of generating a technical elective follow-on class to illustrate the signals and systems concepts on the Beagleboard.
|-
|Monty Hayes
|Georgia Tech, Professor, Atlanta, GA and
Chung-Ang University Distinguished Foreign Professor, Seoul, Korea
|I have no linux experience, have taught courses on DSP chips before
|I would like to develop an undergraduate course using the Beagleboard to teach DSP.
|-
|Oleg Muratov
|University of Trento, Itay
|I am a PhD student and I have limited Linux experience.
|I am planning to give a course to undergraduate students on DSP probably using some hardware.
|}

=== Labs ===

Here's an additional handout that didn't make it in time for the printers.

[[VideoThru Lab]]

=== Post Workshop ===

Here ([[Getting_a_Workshop_SD_Image]]) are instructions on how to put the tutorial image on your SD card.

== 2011 IEEE ICASSP Tutorial ==
{|
| '''Title:'''
| From DSP Chips to Embedded Processors for Teaching Digital Signal Processing
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Prague, Czech Republic
|-
| '''Date:'''
| Sunday May 22nd, 2011, Afternoon
|-
| '''Link'''
| [http://www.icassp2011.com/en/tutorials/tutorial-5]
|}

=== Abstract:===
This hands-on tutorial presents ideas on how to use TI’s OMAP 3530-based BeagleBoard (www.BeagleBoard.org) for teaching embedded media processing using Open Source resources. The BeagleBoard is Open Source hardware that has sold over 16,000 units since its introduction less than 2 years ago and has a thriving Open Source Software community.
Today’s media handling embedded processors have come a long way from the limited performance of 8- or 16-bit embedded processors or the limited functionality of a dedicated DSP chip. Our students need to see that the days of the single DSP chip are almost over and they need to be prepared for working with DSPs embedded with other processors.
The OMAP3530 processor contains both an ARM Cortex-A9 processor and a ‘C6400 DSP and it and chips like it are being used in products today.
The workshop activities include:
# hands-on exercises to get participants familiar with using the Beagle,
# demonstrations of what the Beagle can do, including streaming video and synthesizing speech and
# discussions of what topics to include in an embedded Linux class.
Participants will receive a BeagleBoard and course materials.

=== Pre Tutorial ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]]. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|-
|Melani Plett
|Seattle Pacific University,
Seattle, Washington, USA
|I teach an undergraduate signals and systems course. I have no Linux experience, though I did use Unix years ago.
|I am thinking of generating a technical elective follow-on class to illustrate the signals and systems concepts on the Beagleboard.
|-
|Matt Gately
|University of Oklahoma, Norman, OK, USA
|I am a PhD student and I use Linux in my research.
|I would love to someday teach a DSP course using embedded systems such as FPGA or microcontroller boards.

|}

=== Labs ===

Here's an additional handout that didn't make it in time for the printers.

[[AudioThru Lab]]

=== Post Tutorial ===

Here ([[Getting_a_Workshop_SD_Image]]) are instructions on how to put the tutorial image on your SD card.

== 2011 IEEE SPEd (Signal Processing Society 14th DSP Workshop & 6th SPEd Workshop) ==
{|
| '''Title:'''
| Moving Beyond the DSP and Teaching 32-bit Embedded Processors Using the BeagleBoard
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Enchantment Resort, Sedona, Arizona
|-
| '''Date:'''
| Thursday 6 January, 2011 Time: 14:00 - 17:30
|}

=== Post Workshop ===
Here are some things you might want to do now that the workshop is over.

Here are instructions on how to create the SD card that was used in the workshop.
* Go here ([[ECE597_Getting_your_Beagle_running_(precompiled)#From_beagleboard-validation.s3.amazonaws.com]]) to download and install the base image for the Beagle. This will install the kernel and all the files needed to run many of the demos.
* Download [http://www.rose-hulman.edu/~yoder/Beagle/SPEd2011WorkshopFiles.zip this zip file] to get the extra files used in the workshop. Copy it to your BeagleBoard and unzip it there. This file contains the '''VideoThru''', '''c6run_target''', '''hello.c''' and '''helloBeagle.c''' files.
* Download the workshop pptx [http://www.rose-hulman.edu/~yoder/Beagle/SPEd2011WorkshopPPTX.zip here].

=== Pre Workshop ===
If you are an overachiever (not required) go here ([[ECE497 Lab13 Using the DSP via c6run]]) to learn how to install the ARM and DSP development tools on your Linux system (Ubuntu 10.4 LTS is required). If you don't have Ubuntu installed, go [http://processors.wiki.ti.com/index.php/How_to_Build_a_Ubuntu_Linux_host_under_VirtualBox here] to learn how to install it in a virtual machine under windows.

These installs are not required for the workshop; however editing the the table below ''is''.

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program www.ti.com/university helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|-
| Steve Chadwick
| Embry-Riddle Aeronautical University, Prescott, AZ
| Very new to DSP and hoping develop sufficient depth to teach it next academic year.
| Interests: Pretty much everything in science.
|-
| Mark Wickert
| University of Colorado, Colorado Springs, CO, USA
| I have played on and off with Linux for about 10 years, never done any real-time DSP under this OS however.
| I regularly teach DSP and related courses. I am using the C6713 today, but ready to move forward. I recently started playing with ARM processors (not the BeagleBoard until now).
|-
| Shane Cotter
| Union College, Schenectady, NY
| I have taught DSP courses. I have used Unix/Linux in the past but not for real-time DSP.
| The Beagleboard seems like a great platform and I'm interested in learning about it and its potential uses in courses.
|-
| Jake Gunther
| Utah State University
| I have taught DSP and communication systems for over ten years.
| I want to move from a simulation-based teaching approach to a real-time approach.
|}

== 2010 ICASSP Workshop ==
{|
| '''Title:'''
| 32-bit Embedded Linux-based Signal Processing – Hands on Workshop
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| ICASSP 2010, Dallas, Texas
|-
| '''Date:'''
| Monday, March 15 2010, 13:30 - 17:00
|}

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:20%" | email
! style="width:40%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| [http://www.rose-hulman.edu/~yoder]
| I teach 32-bit embedded with the Beagle. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|David V. Anderson
|Georgia Institute of Technology
|
|Teaching DSP using BeagleBoard as a real-time platform.
|-
|Andres Kwasinski
|Rochester Institute of Technology
|[http://people.rit.edu/axkeec/]
|Teaching DSP to Computer Engineers using real-world platforms.
|-
|Roger West
|Utah State University
|
|Teaching DSP to ECE students using real-time platforms.
|}

=== Labs ===
Here is a list of the hands on exercises we will be doing in the 2010 workshop. Many have suggestions for additional homework that you can do once you are back home and have a network connection.

# [[2010 ICASSP Lab 1 Wiring_and_Running the Beagle]]
# [[2010 ICASSP Lab 2 The Boot Sequence]]

{{YoderFoot}}

BeagleBoard Education Workshops

2013-05-18T15:31:34Z

Yoder: /* 2013 ASEE Workshop */ Added

[[Category:ECE497 |W]]
[[Category:BeagleBoard]]
[[Category:Workshops]]
[[Category:Education]]
{{YoderHead}}

== 2012 ASEE Workshop ==
{|
| '''Title:'''
| U216·WORKSHOP: BeagleBone - A Hands-on Workshop
|-
| '''Presentors:'''
| Dr. Steven F Barrett P.E., Jason Kridner, Mark A. Yoder
|-
| '''Location:'''
| Atlanta, Omni CNN Center Hotel, Omni - Chestnut
|-
| '''Date:'''
| 23-June-2013
|-
| '''Link'''
| [http://www.asee.org/public/conferences/20/registration/view_session?session_id=2420 ASEE site]
|}

=== Abstract:===

'''Ticketed event: $100.00 advanced registration and $110.00 on site registration'''

BeagleBone is a low cost, open hardware computer first introduced in November 2011 by BeagleBoard.org, a community of developers sponsored by Texas Instruments. BeagleBone hosts a powerful 32-bit, super-scalar ARM Cortex A8 processor operating at 720 MHz. Yet it is small enough to fit in an Altoids mint tin box. The "Bone'' may be used in a wide variety of projects from middle school science fair projects to senior design projects to first prototypes of very complex systems. Novice users may access the power of the Bone through the user-friendly Bonescript environment. Seasoned users may take full advantage of the Bone's power using the underlying Linux-based operating system, a host of feature extension boards (Capes) and a wide variety of open source libraries. This hands on workshop provides an introduction to this powerful computer and has been designed for a wide variety of users including the first time novice through the seasoned embedded system design professional.

Workshop participants will receive a BeagleBone board and also a BeagleBone book courtesy of BeagleBoard.org and Morgan and Claypool Publishers. This workshop is subsidized by Texas Instruments (TI).

=== Pre Workshop ===

=== Labs ===

=== Post Workshop ===

== 2012 Engibous Summit Workshop ==
{|
| '''Title:'''
| Hands-on workshop on Embedded Linux on BeagleBone
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Dallas
|-
| '''Date:'''
| 30-July-2012
|-
| '''Link'''
| [http://www.ti.com/corp/docs/landing/universityprogram/prize.htm Engibous Summit]
|}

=== Abstract:===

???

=== Pre Workshop ===

You will be mailed some information about the workshop and some things for you to do before arriving.

--Mark

=== Labs ===

=== Post Workshop ===

== 2012 Chandigarh Workshop ==
{|
| '''Title:'''
| Hands-on workshop on Embedded Linux on Beagleboard
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| [http://www.uniti.in/events/venueevents/73-chitkara-school-of-engineering-a-technology Chitkara School of Engineering & Technology] - Chandigarh, India
|-
| '''Date:'''
| 18-20 June-2012
|-
| '''Link'''
| [http://www.uniti.in/events/details/128-hands-on-workshop-on-embedded-linux-on-beagleboard http://www.uniti.in/events/details/128-hands-on-workshop-on-embedded-linux-on-beagleboard]
|}

=== Abstract:===

Beagleboard is a low-cost open-source embedded system development platform. It is based on Texas Instruments DM3730 processor, which includes an on-chip ARM Cortex-A8 processor core, a Texas Instruments C6x DSP core, and a host of peripherals. Beagleboard is a single board computer, which provides adequate performance to run Linux software, yet has a power consumption lower than 2W. A large number of embedded applications have been developed on Beagleboard ([http://www.beagleboard.org www.beagleboard.org]) Module A provides a gentle introduction to the subject of Embedded Linux, Linux Systems Programming and Linux Kernel Programming. The intention of Module B is to provide a hands-on exposure to running Embedded Linux operating system on the Beagleboard and develop system software on the Beagleboard.
=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]].
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|}

=== Labs ===

=== Post Workshop ===

== 2012 Hyderabad Workshop ==
{|
| '''Title:'''
| Three-day workshop on Embedded Linux on Beagleboard
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| [http://www.uniti.in/events/venueevents/69-c-dac-hyderabad C-DAC Hyderabad] - Hyderabad, India
|-
| '''Date:'''
| 14-16 June-2012
|-
| '''Link'''
| [http://www.uniti.in/events/details/123-three-day-workshop-on-embedded-linux-on-beagleboard http://www.uniti.in/events/details/123-three-day-workshop-on-embedded-linux-on-beagleboard]
|}

=== Abstract:===

Linux, which is an “open source” operating system and enjoys considerable popularity on general-purpose computers, is becoming popular in the embedded world also. Different versions and variants of Linux are now available on embedded platforms. In this workshop, the intention is to provide a hands-on introduction to concepts of Linux Systems/Kernel Programming and Embedded Linux

=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]].
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|}

=== Labs ===

=== Post Workshop ===

== 2012 Bangalore Workshop ==
{|
| '''Title:'''
| 6-day modular workshop on Embedded Linux
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| [http://www.uniti.in/events/venueevents/68-cambridge-institute-of-technology Cambridge Institute of Technology] - Bangalore, India
|-
| '''Date:'''
| 11-13 June-2012
|-
| '''Link'''
| [http://www.uniti.in/events/details/122-6-day-modular-workshop-on-embedded-linux www.uniti.in/events/details/122-6-day-modular-workshop-on-embedded-linux]
|}

=== Abstract:===

'''Module A''' provides an overview of basic concepts of Linux, Linux Systems Programming, Linux Kernel Programming, and Embedded Systems. Module A will also include an introduction to Beagleboard, an open-source, low-cost, low-power embedded system development platform. '''Module A''' will be conducted jointly by a team of experts from industry and academia. In '''Module B''', aspects of Embedded Linux on Beagleboard will be explored in greater depth. Module B will be conducted by Prof. Mark A. Yoder of Rose-Hulman Institute of Technology, USA.

=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]].
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|}

=== Labs ===

=== Post Workshop ===

== 2011 FIE Workshop - Cancelled ==
{|
| '''Title:'''
| From DSP Chips to Embedded Processors for Teaching Digital Signal Processing
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Holiday Inn Salon F, Rapid City, South Dakota
|-
| '''Date:'''
| Wednesday, October 12, 2011, 2:30 p.m. - 5:30 p.m
|-
| '''Link'''
| [http://fie-conference.org/fie2011/] [http://fie-conference.org/fie2011/Pages/workshops.htm#SCRL6]
|}

=== Abstract:===

The goal of this hands-on tutorial is to present ideas on how to use Texas Instrument’s DM 3730-based BeagleBoard xM ([www.BeagleBoard.org www.BeagleBoard.org]) for teaching embedded processing using Open Source resources. The DM 3730 is a dual core processor with an ARM Cortex-a8 core and a TI ‘c64x DSP core. The BeagleBoard is Open Source hardware that has sold over 30,000 units since its introduction less than 2 years ago and has a thriving Open Source Software community.

The BeagleBoard has many uses in the classroom. This workshop will show some of those uses and present some of the challenges in teaching with Open Source.

The workshop activities will include:

* several hands-on exercises to get participants familiar with using the Beagle, and how it differs from a traditional 8- or 16-bit microcomputer.
* several demonstrations of what the Beagle can do, such as streaming video and programming its DSP and discussions of what topics to include in an embedded/DSP class including dealing with open source comminutes.
* This workshop is targeted to those who are teaching embedded processors or DSP hardware. Some Linux background would be helpful, but not required. Those with little or no Linux experience will be paired with those with more experience.

=== Post Workshop ===

Even though the workshop has been cancelled, you can still do the exercises. Here ([[Getting a Workshop SD Image]]) are instructions on how to put the tutorial image on your SD card.

Here ([[EBC Embedded Beagle Class Topics]]) is a list of topics I cover in my class. If you have questions, please email me.

== 2011 IEEE ICASSP Workshop ==
{|
| '''Title:'''
| How 32-bit Embedded Processors Change the Focus in Teaching DSP Hardware
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Prague, Czech Republic
|-
| '''Date:'''
| Monday May 23rd, 2011, Afternoon
|-
| '''Link'''
| [http://www.icassp2011.com/en/registration]
|}

=== Abstract:===
This hands-on tutorial presents ideas on how to use TI’s OMAP 3530-based BeagleBoard (www.BeagleBoard.org) for teaching embedded media processing using Open Source resources. The BeagleBoard is Open Source hardware that has sold over 20,000 units since its introduction less than 2 years ago and has a thriving Open Source Software community.
After the introduction, this workshop will complement the Sunday afternoon tutorial “From DSP Chips to Embedded Processors for Teaching Digital Signal Processing”. The Sunday workshop examples focus on programming the ‘C64 DSP on the OMAP3530. This workshop will focus on using Open Source software for media processing (such as GStreamer, OpenCV, etc.) and using the OMAP display subsystem for handling video.
The workshop activities will include:
# Several hands-on exercises to get participants familiar with using the Beagle, (same as tutorial)
# Several demonstrations of what the Beagle can do using Open Source software, including using the display subsystem, recognizing speech, computer vision
# Discussions of what topics to include in an embedded Linux class.
No BeagleBoards will given out.

=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]]. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|-
|Melani Plett
|Seattle Pacific University,
Seattle, Washington, USA
|I teach an undergraduate signals and systems course. I have no Linux experience, though I did use Unix years ago.
|I am thinking of generating a technical elective follow-on class to illustrate the signals and systems concepts on the Beagleboard.
|-
|Monty Hayes
|Georgia Tech, Professor, Atlanta, GA and
Chung-Ang University Distinguished Foreign Professor, Seoul, Korea
|I have no linux experience, have taught courses on DSP chips before
|I would like to develop an undergraduate course using the Beagleboard to teach DSP.
|-
|Oleg Muratov
|University of Trento, Itay
|I am a PhD student and I have limited Linux experience.
|I am planning to give a course to undergraduate students on DSP probably using some hardware.
|}

=== Labs ===

Here's an additional handout that didn't make it in time for the printers.

[[VideoThru Lab]]

=== Post Workshop ===

Here ([[Getting_a_Workshop_SD_Image]]) are instructions on how to put the tutorial image on your SD card.

== 2011 IEEE ICASSP Tutorial ==
{|
| '''Title:'''
| From DSP Chips to Embedded Processors for Teaching Digital Signal Processing
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Prague, Czech Republic
|-
| '''Date:'''
| Sunday May 22nd, 2011, Afternoon
|-
| '''Link'''
| [http://www.icassp2011.com/en/tutorials/tutorial-5]
|}

=== Abstract:===
This hands-on tutorial presents ideas on how to use TI’s OMAP 3530-based BeagleBoard (www.BeagleBoard.org) for teaching embedded media processing using Open Source resources. The BeagleBoard is Open Source hardware that has sold over 16,000 units since its introduction less than 2 years ago and has a thriving Open Source Software community.
Today’s media handling embedded processors have come a long way from the limited performance of 8- or 16-bit embedded processors or the limited functionality of a dedicated DSP chip. Our students need to see that the days of the single DSP chip are almost over and they need to be prepared for working with DSPs embedded with other processors.
The OMAP3530 processor contains both an ARM Cortex-A9 processor and a ‘C6400 DSP and it and chips like it are being used in products today.
The workshop activities include:
# hands-on exercises to get participants familiar with using the Beagle,
# demonstrations of what the Beagle can do, including streaming video and synthesizing speech and
# discussions of what topics to include in an embedded Linux class.
Participants will receive a BeagleBoard and course materials.

=== Pre Tutorial ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]]. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|-
|Melani Plett
|Seattle Pacific University,
Seattle, Washington, USA
|I teach an undergraduate signals and systems course. I have no Linux experience, though I did use Unix years ago.
|I am thinking of generating a technical elective follow-on class to illustrate the signals and systems concepts on the Beagleboard.
|-
|Matt Gately
|University of Oklahoma, Norman, OK, USA
|I am a PhD student and I use Linux in my research.
|I would love to someday teach a DSP course using embedded systems such as FPGA or microcontroller boards.

|}

=== Labs ===

Here's an additional handout that didn't make it in time for the printers.

[[AudioThru Lab]]

=== Post Tutorial ===

Here ([[Getting_a_Workshop_SD_Image]]) are instructions on how to put the tutorial image on your SD card.

== 2011 IEEE SPEd (Signal Processing Society 14th DSP Workshop & 6th SPEd Workshop) ==
{|
| '''Title:'''
| Moving Beyond the DSP and Teaching 32-bit Embedded Processors Using the BeagleBoard
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Enchantment Resort, Sedona, Arizona
|-
| '''Date:'''
| Thursday 6 January, 2011 Time: 14:00 - 17:30
|}

=== Post Workshop ===
Here are some things you might want to do now that the workshop is over.

Here are instructions on how to create the SD card that was used in the workshop.
* Go here ([[ECE597_Getting_your_Beagle_running_(precompiled)#From_beagleboard-validation.s3.amazonaws.com]]) to download and install the base image for the Beagle. This will install the kernel and all the files needed to run many of the demos.
* Download [http://www.rose-hulman.edu/~yoder/Beagle/SPEd2011WorkshopFiles.zip this zip file] to get the extra files used in the workshop. Copy it to your BeagleBoard and unzip it there. This file contains the '''VideoThru''', '''c6run_target''', '''hello.c''' and '''helloBeagle.c''' files.
* Download the workshop pptx [http://www.rose-hulman.edu/~yoder/Beagle/SPEd2011WorkshopPPTX.zip here].

=== Pre Workshop ===
If you are an overachiever (not required) go here ([[ECE497 Lab13 Using the DSP via c6run]]) to learn how to install the ARM and DSP development tools on your Linux system (Ubuntu 10.4 LTS is required). If you don't have Ubuntu installed, go [http://processors.wiki.ti.com/index.php/How_to_Build_a_Ubuntu_Linux_host_under_VirtualBox here] to learn how to install it in a virtual machine under windows.

These installs are not required for the workshop; however editing the the table below ''is''.

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program www.ti.com/university helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|-
| Steve Chadwick
| Embry-Riddle Aeronautical University, Prescott, AZ
| Very new to DSP and hoping develop sufficient depth to teach it next academic year.
| Interests: Pretty much everything in science.
|-
| Mark Wickert
| University of Colorado, Colorado Springs, CO, USA
| I have played on and off with Linux for about 10 years, never done any real-time DSP under this OS however.
| I regularly teach DSP and related courses. I am using the C6713 today, but ready to move forward. I recently started playing with ARM processors (not the BeagleBoard until now).
|-
| Shane Cotter
| Union College, Schenectady, NY
| I have taught DSP courses. I have used Unix/Linux in the past but not for real-time DSP.
| The Beagleboard seems like a great platform and I'm interested in learning about it and its potential uses in courses.
|-
| Jake Gunther
| Utah State University
| I have taught DSP and communication systems for over ten years.
| I want to move from a simulation-based teaching approach to a real-time approach.
|}

== 2010 ICASSP Workshop ==
{|
| '''Title:'''
| 32-bit Embedded Linux-based Signal Processing – Hands on Workshop
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| ICASSP 2010, Dallas, Texas
|-
| '''Date:'''
| Monday, March 15 2010, 13:30 - 17:00
|}

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:20%" | email
! style="width:40%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| [http://www.rose-hulman.edu/~yoder]
| I teach 32-bit embedded with the Beagle. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|David V. Anderson
|Georgia Institute of Technology
|
|Teaching DSP using BeagleBoard as a real-time platform.
|-
|Andres Kwasinski
|Rochester Institute of Technology
|[http://people.rit.edu/axkeec/]
|Teaching DSP to Computer Engineers using real-world platforms.
|-
|Roger West
|Utah State University
|
|Teaching DSP to ECE students using real-time platforms.
|}

=== Labs ===
Here is a list of the hands on exercises we will be doing in the 2010 workshop. Many have suggestions for additional homework that you can do once you are back home and have a network connection.

# [[2010 ICASSP Lab 1 Wiring_and_Running the Beagle]]
# [[2010 ICASSP Lab 2 The Boot Sequence]]

{{YoderFoot}}

BeagleBoard Education Workshops

2013-05-18T15:21:37Z

Yoder:

[[Category:ECE497 |W]]
[[Category:BeagleBoard]]
[[Category:Workshops]]
[[Category:Education]]
{{YoderHead}}

== 2012 Engibous Summit Workshop ==
{|
| '''Title:'''
| Hands-on workshop on Embedded Linux on BeagleBone
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Dallas
|-
| '''Date:'''
| 30-July-2012
|-
| '''Link'''
| [http://www.ti.com/corp/docs/landing/universityprogram/prize.htm Engibous Summit]
|}

=== Abstract:===

???

=== Pre Workshop ===

You will be mailed some information about the workshop and some things for you to do before arriving.

--Mark

=== Labs ===

=== Post Workshop ===

== 2012 Chandigarh Workshop ==
{|
| '''Title:'''
| Hands-on workshop on Embedded Linux on Beagleboard
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| [http://www.uniti.in/events/venueevents/73-chitkara-school-of-engineering-a-technology Chitkara School of Engineering & Technology] - Chandigarh, India
|-
| '''Date:'''
| 18-20 June-2012
|-
| '''Link'''
| [http://www.uniti.in/events/details/128-hands-on-workshop-on-embedded-linux-on-beagleboard http://www.uniti.in/events/details/128-hands-on-workshop-on-embedded-linux-on-beagleboard]
|}

=== Abstract:===

Beagleboard is a low-cost open-source embedded system development platform. It is based on Texas Instruments DM3730 processor, which includes an on-chip ARM Cortex-A8 processor core, a Texas Instruments C6x DSP core, and a host of peripherals. Beagleboard is a single board computer, which provides adequate performance to run Linux software, yet has a power consumption lower than 2W. A large number of embedded applications have been developed on Beagleboard ([http://www.beagleboard.org www.beagleboard.org]) Module A provides a gentle introduction to the subject of Embedded Linux, Linux Systems Programming and Linux Kernel Programming. The intention of Module B is to provide a hands-on exposure to running Embedded Linux operating system on the Beagleboard and develop system software on the Beagleboard.
=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]].
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|}

=== Labs ===

=== Post Workshop ===

== 2012 Hyderabad Workshop ==
{|
| '''Title:'''
| Three-day workshop on Embedded Linux on Beagleboard
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| [http://www.uniti.in/events/venueevents/69-c-dac-hyderabad C-DAC Hyderabad] - Hyderabad, India
|-
| '''Date:'''
| 14-16 June-2012
|-
| '''Link'''
| [http://www.uniti.in/events/details/123-three-day-workshop-on-embedded-linux-on-beagleboard http://www.uniti.in/events/details/123-three-day-workshop-on-embedded-linux-on-beagleboard]
|}

=== Abstract:===

Linux, which is an “open source” operating system and enjoys considerable popularity on general-purpose computers, is becoming popular in the embedded world also. Different versions and variants of Linux are now available on embedded platforms. In this workshop, the intention is to provide a hands-on introduction to concepts of Linux Systems/Kernel Programming and Embedded Linux

=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]].
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|}

=== Labs ===

=== Post Workshop ===

== 2012 Bangalore Workshop ==
{|
| '''Title:'''
| 6-day modular workshop on Embedded Linux
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| [http://www.uniti.in/events/venueevents/68-cambridge-institute-of-technology Cambridge Institute of Technology] - Bangalore, India
|-
| '''Date:'''
| 11-13 June-2012
|-
| '''Link'''
| [http://www.uniti.in/events/details/122-6-day-modular-workshop-on-embedded-linux www.uniti.in/events/details/122-6-day-modular-workshop-on-embedded-linux]
|}

=== Abstract:===

'''Module A''' provides an overview of basic concepts of Linux, Linux Systems Programming, Linux Kernel Programming, and Embedded Systems. Module A will also include an introduction to Beagleboard, an open-source, low-cost, low-power embedded system development platform. '''Module A''' will be conducted jointly by a team of experts from industry and academia. In '''Module B''', aspects of Embedded Linux on Beagleboard will be explored in greater depth. Module B will be conducted by Prof. Mark A. Yoder of Rose-Hulman Institute of Technology, USA.

=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]].
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|}

=== Labs ===

=== Post Workshop ===

== 2011 FIE Workshop - Cancelled ==
{|
| '''Title:'''
| From DSP Chips to Embedded Processors for Teaching Digital Signal Processing
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Holiday Inn Salon F, Rapid City, South Dakota
|-
| '''Date:'''
| Wednesday, October 12, 2011, 2:30 p.m. - 5:30 p.m
|-
| '''Link'''
| [http://fie-conference.org/fie2011/] [http://fie-conference.org/fie2011/Pages/workshops.htm#SCRL6]
|}

=== Abstract:===

The goal of this hands-on tutorial is to present ideas on how to use Texas Instrument’s DM 3730-based BeagleBoard xM ([www.BeagleBoard.org www.BeagleBoard.org]) for teaching embedded processing using Open Source resources. The DM 3730 is a dual core processor with an ARM Cortex-a8 core and a TI ‘c64x DSP core. The BeagleBoard is Open Source hardware that has sold over 30,000 units since its introduction less than 2 years ago and has a thriving Open Source Software community.

The BeagleBoard has many uses in the classroom. This workshop will show some of those uses and present some of the challenges in teaching with Open Source.

The workshop activities will include:

* several hands-on exercises to get participants familiar with using the Beagle, and how it differs from a traditional 8- or 16-bit microcomputer.
* several demonstrations of what the Beagle can do, such as streaming video and programming its DSP and discussions of what topics to include in an embedded/DSP class including dealing with open source comminutes.
* This workshop is targeted to those who are teaching embedded processors or DSP hardware. Some Linux background would be helpful, but not required. Those with little or no Linux experience will be paired with those with more experience.

=== Post Workshop ===

Even though the workshop has been cancelled, you can still do the exercises. Here ([[Getting a Workshop SD Image]]) are instructions on how to put the tutorial image on your SD card.

Here ([[EBC Embedded Beagle Class Topics]]) is a list of topics I cover in my class. If you have questions, please email me.

== 2011 IEEE ICASSP Workshop ==
{|
| '''Title:'''
| How 32-bit Embedded Processors Change the Focus in Teaching DSP Hardware
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Prague, Czech Republic
|-
| '''Date:'''
| Monday May 23rd, 2011, Afternoon
|-
| '''Link'''
| [http://www.icassp2011.com/en/registration]
|}

=== Abstract:===
This hands-on tutorial presents ideas on how to use TI’s OMAP 3530-based BeagleBoard (www.BeagleBoard.org) for teaching embedded media processing using Open Source resources. The BeagleBoard is Open Source hardware that has sold over 20,000 units since its introduction less than 2 years ago and has a thriving Open Source Software community.
After the introduction, this workshop will complement the Sunday afternoon tutorial “From DSP Chips to Embedded Processors for Teaching Digital Signal Processing”. The Sunday workshop examples focus on programming the ‘C64 DSP on the OMAP3530. This workshop will focus on using Open Source software for media processing (such as GStreamer, OpenCV, etc.) and using the OMAP display subsystem for handling video.
The workshop activities will include:
# Several hands-on exercises to get participants familiar with using the Beagle, (same as tutorial)
# Several demonstrations of what the Beagle can do using Open Source software, including using the display subsystem, recognizing speech, computer vision
# Discussions of what topics to include in an embedded Linux class.
No BeagleBoards will given out.

=== Pre Workshop ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]]. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|-
|Melani Plett
|Seattle Pacific University,
Seattle, Washington, USA
|I teach an undergraduate signals and systems course. I have no Linux experience, though I did use Unix years ago.
|I am thinking of generating a technical elective follow-on class to illustrate the signals and systems concepts on the Beagleboard.
|-
|Monty Hayes
|Georgia Tech, Professor, Atlanta, GA and
Chung-Ang University Distinguished Foreign Professor, Seoul, Korea
|I have no linux experience, have taught courses on DSP chips before
|I would like to develop an undergraduate course using the Beagleboard to teach DSP.
|-
|Oleg Muratov
|University of Trento, Itay
|I am a PhD student and I have limited Linux experience.
|I am planning to give a course to undergraduate students on DSP probably using some hardware.
|}

=== Labs ===

Here's an additional handout that didn't make it in time for the printers.

[[VideoThru Lab]]

=== Post Workshop ===

Here ([[Getting_a_Workshop_SD_Image]]) are instructions on how to put the tutorial image on your SD card.

== 2011 IEEE ICASSP Tutorial ==
{|
| '''Title:'''
| From DSP Chips to Embedded Processors for Teaching Digital Signal Processing
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Prague, Czech Republic
|-
| '''Date:'''
| Sunday May 22nd, 2011, Afternoon
|-
| '''Link'''
| [http://www.icassp2011.com/en/tutorials/tutorial-5]
|}

=== Abstract:===
This hands-on tutorial presents ideas on how to use TI’s OMAP 3530-based BeagleBoard (www.BeagleBoard.org) for teaching embedded media processing using Open Source resources. The BeagleBoard is Open Source hardware that has sold over 16,000 units since its introduction less than 2 years ago and has a thriving Open Source Software community.
Today’s media handling embedded processors have come a long way from the limited performance of 8- or 16-bit embedded processors or the limited functionality of a dedicated DSP chip. Our students need to see that the days of the single DSP chip are almost over and they need to be prepared for working with DSPs embedded with other processors.
The OMAP3530 processor contains both an ARM Cortex-A9 processor and a ‘C6400 DSP and it and chips like it are being used in products today.
The workshop activities include:
# hands-on exercises to get participants familiar with using the Beagle,
# demonstrations of what the Beagle can do, including streaming video and synthesizing speech and
# discussions of what topics to include in an embedded Linux class.
Participants will receive a BeagleBoard and course materials.

=== Pre Tutorial ===

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle [[ECE497 - 32-bit Embedded Linux, Rose-Hulman]]. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program [http://www.ti.com/university www.ti.com/university] helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|-
|Melani Plett
|Seattle Pacific University,
Seattle, Washington, USA
|I teach an undergraduate signals and systems course. I have no Linux experience, though I did use Unix years ago.
|I am thinking of generating a technical elective follow-on class to illustrate the signals and systems concepts on the Beagleboard.
|-
|Matt Gately
|University of Oklahoma, Norman, OK, USA
|I am a PhD student and I use Linux in my research.
|I would love to someday teach a DSP course using embedded systems such as FPGA or microcontroller boards.

|}

=== Labs ===

Here's an additional handout that didn't make it in time for the printers.

[[AudioThru Lab]]

=== Post Tutorial ===

Here ([[Getting_a_Workshop_SD_Image]]) are instructions on how to put the tutorial image on your SD card.

== 2011 IEEE SPEd (Signal Processing Society 14th DSP Workshop & 6th SPEd Workshop) ==
{|
| '''Title:'''
| Moving Beyond the DSP and Teaching 32-bit Embedded Processors Using the BeagleBoard
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| Enchantment Resort, Sedona, Arizona
|-
| '''Date:'''
| Thursday 6 January, 2011 Time: 14:00 - 17:30
|}

=== Post Workshop ===
Here are some things you might want to do now that the workshop is over.

Here are instructions on how to create the SD card that was used in the workshop.
* Go here ([[ECE597_Getting_your_Beagle_running_(precompiled)#From_beagleboard-validation.s3.amazonaws.com]]) to download and install the base image for the Beagle. This will install the kernel and all the files needed to run many of the demos.
* Download [http://www.rose-hulman.edu/~yoder/Beagle/SPEd2011WorkshopFiles.zip this zip file] to get the extra files used in the workshop. Copy it to your BeagleBoard and unzip it there. This file contains the '''VideoThru''', '''c6run_target''', '''hello.c''' and '''helloBeagle.c''' files.
* Download the workshop pptx [http://www.rose-hulman.edu/~yoder/Beagle/SPEd2011WorkshopPPTX.zip here].

=== Pre Workshop ===
If you are an overachiever (not required) go here ([[ECE497 Lab13 Using the DSP via c6run]]) to learn how to install the ARM and DSP development tools on your Linux system (Ubuntu 10.4 LTS is required). If you don't have Ubuntu installed, go [http://processors.wiki.ti.com/index.php/How_to_Build_a_Ubuntu_Linux_host_under_VirtualBox here] to learn how to install it in a virtual machine under windows.

These installs are not required for the workshop; however editing the the table below ''is''.

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list. You will have to create an eLinux account before you can edit the page.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:30%" | Linux/DSP Background
! style="width:30%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| I've been using various flavors of Unix/Linux since the late '70s, but there is always more to learn.
I've taught a 'C6713 based DSP class years ago.
| I teach 32-bit embedded with the Beagle. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|Cathy Wicks
|Texas Instruments, University Program Manager
|I am a HUGE fan of Beagleboard and very interested to develop a community of teachers using it.
|Our Program www.ti.com/university helps academics use TI Hardware, Software and Chips in their projects and curriculum.
|-
| Steve Chadwick
| Embry-Riddle Aeronautical University, Prescott, AZ
| Very new to DSP and hoping develop sufficient depth to teach it next academic year.
| Interests: Pretty much everything in science.
|-
| Mark Wickert
| University of Colorado, Colorado Springs, CO, USA
| I have played on and off with Linux for about 10 years, never done any real-time DSP under this OS however.
| I regularly teach DSP and related courses. I am using the C6713 today, but ready to move forward. I recently started playing with ARM processors (not the BeagleBoard until now).
|-
| Shane Cotter
| Union College, Schenectady, NY
| I have taught DSP courses. I have used Unix/Linux in the past but not for real-time DSP.
| The Beagleboard seems like a great platform and I'm interested in learning about it and its potential uses in courses.
|-
| Jake Gunther
| Utah State University
| I have taught DSP and communication systems for over ten years.
| I want to move from a simulation-based teaching approach to a real-time approach.
|}

== 2010 ICASSP Workshop ==
{|
| '''Title:'''
| 32-bit Embedded Linux-based Signal Processing – Hands on Workshop
|-
| '''Presentor:'''
| Mark A. Yoder
|-
| '''Location:'''
| ICASSP 2010, Dallas, Texas
|-
| '''Date:'''
| Monday, March 15 2010, 13:30 - 17:00
|}

The purpose of this page is to give you practice editing a wiki and to start building a community of BeagleBoard Educators. Click on the '''edit''' tab above and add your name to the list.

--Mark

{|
! style="width:20%" | Name
! style="width:20%" | School/Company
! style="width:20%" | email
! style="width:40%" | Interests
|-
| Mark A. Yoder
| Rose-Hulman Institute of Technology,
Terre Haute, Indiana, USA
| [http://www.rose-hulman.edu/~yoder]
| I teach 32-bit embedded with the Beagle. DSP is appearing everywhere now. The BeagleBoard is a great environment to teach DSP.
|-
|David V. Anderson
|Georgia Institute of Technology
|
|Teaching DSP using BeagleBoard as a real-time platform.
|-
|Andres Kwasinski
|Rochester Institute of Technology
|[http://people.rit.edu/axkeec/]
|Teaching DSP to Computer Engineers using real-world platforms.
|-
|Roger West
|Utah State University
|
|Teaching DSP to ECE students using real-time platforms.
|}

=== Labs ===
Here is a list of the hands on exercises we will be doing in the 2010 workshop. Many have suggestions for additional homework that you can do once you are back home and have a network connection.

# [[2010 ICASSP Lab 1 Wiring_and_Running the Beagle]]
# [[2010 ICASSP Lab 2 The Boot Sequence]]

{{YoderFoot}}

User:Xinyu1991

2013-05-18T15:19:41Z

Yoder:

[[Category:ECE497Fall2012 |UX]]

User:Whiteer

2013-05-18T15:19:27Z

Yoder:

[[Category:ECE497Fall2012 |Uw]]
== About Me ==
;Elias White
:Pursuing a B.Sc. in Electrical Engineering
:Technical interest areas:
::* Signal/Image Processing
::* Robotics
::* Mathematics in general
:My [http://www.linkedin.com/profile/view?id=139481444&trk=tab_pro Linkedin] profile

== Projects ==
Pending.

== Mini-Projects ==
Pending.

User:Correlbn

2013-05-18T15:19:15Z

Yoder:

[[Category:ECE497Fall2012 |Uc]]

User:Shinnsm

2013-05-18T15:19:01Z

Yoder:

Stephen Shinn

Computer Engineering major, class of 2013.

== Projects ==
* [[SparkFun: 0.5" Force Sensitive Resistor]]
* [[ECE497 Project: XBee]]

[[Category:ECE497Fall2012 |Us]]