Brian's Life

Raspberry Pi Robot + Wii remote (Phase 1)

2013-03-05T11:35:00.001-08:00

So I know my last post on how to use the Nintendo Wii controller with the Raspberry Pi was quite popular. I've been working on the next stage of the project which includes connecting my Digilent Cerebot II Atmega64L micro-controller to the Raspberry Pi. This required that I get the SPI connection working between the Pi and the micro-controller and get the Wii remote to control everything. I constructed this project using a set of Python and C programming with modules I either created or borrowed.

Check out Previous Posts to help build the robot!

My current hardware setup looks like this:

Raspberry Pi
Digilent Cerebot II (Atmega64 Microcontroller)
2x H-bridges (Digilent)
2x 6 Volt DC Motors (PWM controlled)
USB to Bluetooth - this one SABRENT at Fry's is what I used
Nintendo Wii Controller
8x 2AA batteries (6V for the Micro, 6V for the Pi)

This picture describes the basic setup of my remote control robot.

Getting Started (Python + Bluetooth):

So in this post i'm going to go over the different parts that build up my robot project. The first one is the Raspberry Pi and Bluetooth module. As I've used in my previous Wii Controller + Python + Raspberry Pi = Amazing! blog I used the Cwiid python module that enables my to connect to a USB Bluetooth dongle I put in my Raspberry Pi. You'll need to install Cwiid for python on the Pi.

sudo apt-get install python-cwiid

Once this is done you'll have to start your program with some python code that connects to the controller. So in your Python code make sure you include the library and then cwiid.Wiimote() connects to the Nintendo Wii remote.

import cwiid
wm = cwiid.Wiimote()

After this you'll want to enable button data reporting.

wm.rpt_mode = cwiid.RPT_BTN

All the buttons on the wii remote have values that can be queried. The best part is they add, so if you're pressing multiple buttons such as left + gas, which are values of 2048 + 1 = 2049. Something like this

wm.state['buttons'] == 2049

(button values for CWiid)

Getting Started (Python + SPI):

The next phase of this project was getting the Serial Peripheral interface (SPI) working with the hardware. As with many parts of my blog this one can take a lot longer as I had to write code in C and make a module that can be called in Python. Please check out my previous post on Python Controlling SPI Bus on the Raspberry Pi and Beagleboard XM for getting Python working. You have to make sure you have SPI enabled in the hardware and from there you can check it by going to the /dev directory. I have another blog Getting SPI working on the Raspberry Pi that helps with getting this setup.

Once your hardware is showing up you can use the SPI.so module I created and call it in Python using something similar to this. For the record my SPI command is in this format, no real reason, just an arbitrary one I chose for hex values.

spidata = ['FFDDLLRR00']

Where the DD is representing the direction of the robot, LL is the left wheel speed and RR is the right wheel speed.

spilist = []
#combine the string
combine = str('FF')+ direction[0] +str(rws)+str('0')+str(lws)+str('0')+str('00')
spilist.append(combine) # append the string of combined direction and wheelspeeds
length_data = len(spilist[0])/2 + 1
spiconnection.transfer(spilist[0], length_data)
time.sleep(.2)

There is a lot more detail here that i'm not going to go into, but all the logic to my code, directions, logic behind what buttons are pushed and such are written in Python and located in file name "robot_version0.x.py" where x is the version number. All my code revisions will be found in the following folder location. Feel free to check back over time for newer versions.

===> My Code versions: version 0.1 at time of post. <===

One of the many important things to know about SPI is how it works. Understanding it has a data line in and out, a clock and a slave select. All data from the master controller goes to all the slaves, but the master just tells which slave to listen. SPI was originally created by Motorola many years ago and is still very popular in computer communication.

Getting Started (SPI + PWM + Atmega64):

So the last part of this project deals with setting up the Digilent Inc board that is a Cerebot II miro-controller. I'm using AVR studio 4.0 and first started by setting up the mico-controller as a SPI slave so it will take in the clock and Slave Select (SS) from the Raspberry Pi.

Once the SPI signal was setup and tested I configured the Pulse Width Modulation (PWM) signals that would talk to the H-Bridges and help higher voltages go to the DC motors. There are registers that control the speed and the direction. So I have the SPI data read in and then it configures what the speed for each wheel is and set the direction. These values change the speed and feed back the data to the Python code saying what was read in, small form of error checking. Check the code folder for "WiiRobotProject" as this is my code for AVR code. Still a work in progress so there are tons of comments and things I was trying. it will look cleaner in my final code release.

There are a bunch of features I would love to still get out of this Cerebot II board, such as the motor feedback, maybe add some SERVOs to control a camera (phase 3)? Time will only tell if i get around to it.

FINAL NOTE (CODE):
Like posted earlier if you would like to check out my code or get some ideas from what I'm doing please check the link below for my source code. Comments. suggestions, and questions are always welcome. Please check out previous tutorials i've written to help with the small details.

===> My Code versions: version 0.1 at time of post. <===

Until next time, peace!

Future NEXT STEPS:

So my next phases of this project will include some of the following as basic ideas:

Battery operated
wireless putty connection for controll
Wii Nunchuck support for camera/laser
Servo control - camera/ front wheels
Hash checking of SPI data

Beagleboard XM - How to install Ubuntu 12.10 (Quantal)

2013-01-19T19:44:00.000-08:00

Hi folks so i'm back after taking quite a bit of time off. Had the unfortunate experience of my dad passing away recently. I truly believe that family comes first so i've been spending my time elsewhere. Thanks for your patients.

Versions of Ubuntu have changed over the last year so i'm going to give you the run down of the latest version, called Ubuntu 12.10 (Quantal) onto your Beagleboard XM. This procedure will be very similar to installing 11.04 but i'm going to give some more broad answers so if links/URLs die and such you can find your way.

Hardware:
-Beagleboard XM (mine is rev C)
-Micro SD card (4GB or higher I recommend)
-Ubuntu system to install things onto your SD card (i'm using VirtualBox with 12.04)

NOTE: you might need to get a few ubuntu packages for your system (virtualbox), i've already installed a few

apt-get install uboot-mkimage btrfs-tools pv

START
The first thing i'm doing is referencing Roberts home site and i'm going to look for the latest version of Ubuntu for the beagleboard that I can find.

Link: http://rcn-ee.net/deb/rootfs

I'm going to look into the Quantal folder and at the time of writing this I see revision 3 is the latest. So lets download and unzip it to get started.

wget http://rcn-ee.net/deb/rootfs/quantal/ubuntu-12.10-r3-minimal-armhf-2013-01-12.tar.xz

Unzip the files...

tar xJf ubuntu-12.10-r3-minimal-armhf-2013-01-12.tar.xz

Lets go into the folder... pressing the tab button finishes the folder/file name just in case you are new to linux syntax.

cd ubuntu-12.10-r3-minimal-armhf-2013-01-12/

So there will be a file located in this folder called 'setup_sdcard.sh' this is a script that sets up the SD card for you, which is pretty neat. All you need to do is call the location of your SD card and away it goes. So I called the following command to see where my SD card was mouted.

df -h

I found that my 4GB SD card was located as /dev/sdb1 but i'm going to use the name /dev/sdb so as not to include just the partition name but the whole drive location.

Now to install the following, you'll need to start the install process, be sure to add your SD card name correctly!! if you have a beagleboard or beaglebone you need to look for the right syntax instread of 'beagle_xm'.

sudo ./setup_sdcard.sh --mmc /dev/sdb --uboot beagle_xm

It will want to confirm that the right drive is being selected, and ask for verification. Just press 'y' and then hit enter. Now this procedure might take a while depending on your connection to your SD card and the speed of your computer/SD card it could take 5-15 mins so be patient. Just to note I did have one pop up warning me, but all i had to do was click ok and it continued.

Once this is complete and you get a message saying everything was complete, unmount your SD card if it hasn't been done in the script already.

Now take the SD card and insert it into your Beagleboard XM and power it up!

Default username/password: ubuntu / temppwd

The first thing I recommend is updating the packages and upgrading everthing.

sudo apt-get update
sudo apt-get upgrade

OPTIONAL INSTALLS AFTER:

Ethernet - One of many ways to enable Ethernet connection

sudo ifconfig -a
sudo dhclient eth0
sudo ifconfig -a

Serial Peripheral Interface (SPI) - How to enable SPI hardware...

cd ~
cd boot/uboot
nano uEnv.txt

You'll need to remove the # symbol from in front of buddy=spidev, once this is done save by pressing the ctrl+x and confirm the name with an enter.

Continue over to my SPI for beagleboard post that shows how to test that everything works. But the short part is you should see the spidev located under the /dev folder like this after rebooting.

GUI Desktop - How to install a simple GUI desktop

To get the GUI installed you can do many different approaches I did a couple, first I started by installing the following, but ran into the problem that xserver no longer made OMAP3 video drivers. I think they're going towards xf86-video-omap. But until that is completely true I did the following.

sudo apt-get install gdm xfce4 network-manager

.
Then I found Robert's script that took care of the rest. Both the previous and the next commands take a couple hours, but you get a few selections for desktops. LXDE and XFCE.

/bin/bash /boot/uboot/tools/ubuntu/minimal_lxde_desktop.sh

Thanks for your feedback, and feel free to email or message me.

Good Sources:

http://elinux.org/BeagleBoardUbuntu#Quantal_12.10_armhf

Wii Controller + Raspberry Pi + Python = Awesome!!

2012-08-03T13:27:00.001-07:00

UPDATE 1/2/2013:
-Corrected button numbers
-Bluetooth commands

So this is going to be a many part series for a robot project i'm working on. This first one covers writing a program that runs on the Raspberry Pi. This program is going to connect through bluetooth to a Nintendo Wii controller and allow you to control the data via Python. Cool I know!

So what I did first was familiarize myself with connecting my Wii controller to my PC (virtual desktop running Ubuntu) and using Cwiid as a module I was able to write a small program to grab the data. Once I knew I could connect and communicate all I needed to do was port this over to my Raspberry Pi.

Parts list:

Raspberry Pi
bluetooth USB dongle - I bought this one SABRENT at Frys Electronics for $10
Wii Remote - Black
Standard Raspberry Pi cables (power, keyboard, monitor)

Make sure you first have debian installed and up to date on your Raspberry Pi. I did a 'how to' earlier that can be found HERE, the only difference is I installed the BETA 'Wheezy' version. Once you have your board up and working make sure you update everything.

sudo apt-get update

sudo apt-get upgrade

This could take hours depending...

Installing the Bluetooth Dongle and drivers

The first thing is to plug your Bluetooth dongle into one of the USB ports of the Pi.
Once you have your Raspberry Pi booted up install the bluetooth package for it. Mine tool about an hour to download. To reduce this time install it without the GUI started.

sudo apt-get install bluetooth

Once it is installed, make sure you can see the bluetooth device and scan for your Wii Remote.

sudo service bluetooth status

If it isn't connected type this to start up your bluetooth, or reboot your Pi:

/etc/init.d/bluetooth start

To get your bluetooth address type,

hcitool dev

This will show your dongle address. Something like this:

Next you can scan for devices. Type the following in, then press the 1+2 on your Wii remote to make it searchable. By pressing the one and two this will put the controller into discovery mode.

hcitool scan

You should see something like this, representing your Wiimote address and name.

Installing CWiiD for Python
Next we need to download CWiiD, this is a great python module that allows us to control a Wii remote in Python, it has been ported to the ARM, x86, and AMD. To download and install type:

sudo apt-get install python-cwiid

Now that it has been installed lets try it out. I've created this program that controls the Wii remote in Python. All you have to do is download it to your main directory.

wget https://sites.google.com/site/brianhensleyfiles/wiimotetest.py

Then to use it type,

sudo python wiimotetest.py

It will ask you to press 1+2 on your Wiimote, once you do so it should say "Wii Remote connected...":

I have this setup for part of my robot project so I have a center point AKA 'position 50' and it has limits of 0 to 100. So as you hold your wii remote horizontal you can press left and right and it will increment +/- 10 from 0 to 100. The other features are pressing the button number 1 and 2 individually. This will be displayed by saying those buttons were pressed. The last option is pressing some of the buttons together and having a message say it is moving forward or backwards and with what position.

I set the MINUS button to turn on and off the Wiiremote rumbling feature.

To disconnect and close the connection I setup the PLUS button on the wii remote to disconnect from the Wiimote.

Understanding CWIID / TIPS:
In python it's important to know more about writing your code to take data from the CWIID module and controller. The first three things I recommend doing are including the module, enabling buttons, and try out the State options.

import cwiid
wm = cwiid.Wiimote()

Next be sure to enable button data reporting,

wm.rpt_mode = cwiid.RPT_BTN

What you can do next is determine what the value of each button is (see picture below). NOTE: when you press mutliple buttons the number values are added together. For example, when you hold the remote horizontally and press the left button it returns a value of 2048, when you press the right button you get 1024.

wm.state['buttons']

If you click button #1 you get a state value of 2, so for example you could press the right button and the button #1 and get a state value of 1024 + 2 = 1026, because they were added. In my python script you can see I did comparison statements of the total status value for multiple buttons. Here is an image I drew up with the button values, labeled in orange. Use this to reference your Python program for what buttons you are pushing.

NOTE: it may be useful to add some delays in, so you have time to return the remote value and have it do something in your program.

Thanks for reading! Please be sure to comment your experience and follow me on twitter to keep up on my next blog posts! twitter.com/bhensley

Useful Links:
http://packages.debian.org/wheezy/bluetooth

http://wiki.debian.org/BluetoothUser

awesome inside wiiremote details:
http://wiibrew.org/wiki/Main_Page

Good Wiimote python example:
http://talk.maemo.org/showthread.php?t=60178

Getting SPI working on the Raspberry Pi

2012-07-25T18:27:00.003-07:00

So one of the phases in my project is connecting the Raspberry Pi to a micro-controller that has many Pulse Width Modulation (PWM) signals. Since the Raspberry doesn't have the number of PWM signals I need to control i'm going to do so through SPI. This post is the 'how to' on getting your SPI signals outputting from your Raspberry Pi. More blogs to come later to show you more details.

INSTALL
First you'll need to download the beta "Wheezy" debian package from here. Then follow the normal instructions for installing it to your board. Once you have installed it and booted up for the second time i ran some updates (That took hours!!)

sudo apt-get update

sudo apt-get upgrade

SPI BACKGROUND
While that is updating lets talk a little bit of SPI background knowledge is needed in order to get this working. First off Serial Peripheral interface (SPI) is made up of 4 wires normally. It is a standard that was designed by Motorola for use with their micro controllers. If you're interested in learning more about SPI i've added the Wikipedia link. Here is what a standard SPI setup looks like, multiple slaves is optional.

SS - Slave Select (Beagleboard community calles this Chip Select (CS))
MOSI - Master Out Slave In
MISO - Master In Slave Out
CLK - Clock

More INSTALL
Next it was time to update to the latest firmware for the board, as the latest has brought out the SPI controller. To do so I used Andrews Hexxeh rpi-update to do this. Some needed tools...

sudo apt-get install git

Now lets download his tool and install change who has access to read/write the tool.

sudo wget http://goo.gl/1BOfJ -O /usr/bin/rpi-update
sudo chmod +x /usr/bin/rpi-update

Once this is done you can run it by calling the following command. (mine took a while).

sudo rpi-update

*NOTE - while I was doing this I ran out of space on my 4GB drive. I figured I wasn't really low on space and when I checked it I found my windows tool originally only made me a 2GB partition. There are many ways to do this, but I used GPARTED to expand my space to the real 4GB. It's a live CD...

SanDisk 4GB Extreme 3 SD Card w/Reader

So once the updates are all completed. I rebooted my Pi.

sudo shutdown -h now

Unplug the power and plug it back in. And when I rebooted I went to my /dev/ directory and found my spidev devices!

The last part of this is to test the SPI signal. I'm going to download spidev_test.c

wget http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=blob_plain;f=Documentation/spi/spidev_test.c -O spidev_test.c

Next we want to short the MISO and MOSI pins. Located as GPIO 9 & GPIO 10 as seen below.

We want to edit the spidev_test.c file so it it uses the correct spidevice in our /dev/ folder.

nano spidev_test.c

scroll down and change the device to "spidev0.0" and then save it by pressing the Ctrl+O to save and Ctrl+X to exit. lets compile this thing and run it now.

gcc spidev_test.c

sudo ./a.out

If you see this it's working.

If you see this it's not working.

For more information on how to control your SPI with python try checking out my post for how to do so on the beagleboard xm. Many have found it useful and i'm sure you will too. Python controlling SPI on the Beagleboard XM

How to get 1080p videos running on my Raspberry Pi

2012-07-13T21:07:00.001-07:00

So one of the first things I was very interested in the Raspberry Pi doing was running 1080p videos. All that power coming from one little controller, I couldn't believe it. So here is my success story of how I got my new raspberry pi to run 1080p videos right after installing Debian onto it.

Here is a video of my working success:

PARTS:

SanDisk 8GB microSD
Raspberry Pi
Standard Series HDMI to DVI Cable
PC - with Windows or Linux
1080p video
1080p TV screen/Monitor ( I recommend Samsung 40 "LED 1080P HDTV)

Installation
There are a few different tools I found that play back HD content. The one I chose to use was called Omxplayer. From a terminal window lets install all the prerequisite applications first.

sudo apt-get install libpcre3-dev libpcrecpp0 libva-dev libva-x11-1 libva1

After some amount of time it will finish and then next we need to install the omxplayer.

wget http://seyrsnys.myzen.co.uk/rpi/omxplayer_0.0.1-arm.deb

After it's downloaded unzip it and install

sudo dpkg -i omxplayer_0.0.1-arm.deb

And that's it!!

Playing a movie
The last part of the tutorial will be playing a movie and how to call and use the omxplayer. Make sure you have a movie file i'm using an episode of friends that is located on a flash drive (extension MKV), many other extensions work too. Here is a list of all the omxplayer options and a general how to use them.

pi@raspberrypi:~$ omxplayer --help
Usage: omxplayer [OPTIONS] [FILE]
Options :
-h / --help print this help
-a / --alang language audio language : e.g. ger
-n / --aidx index audio stream index : e.g. 1
-o / --adev device audio out device : e.g. hdmi/local
-i / --info dump stream format and exit
-s / --stats pts and buffer stats
-p / --passthrough audio passthrough
-d / --deinterlace deinterlacing
-w / --hw hw audio decoding
-3 / --3d switch tv into 3d mode
-y / --hdmiclocksync adjust display refresh rate to match video
-t / --sid index show subtitle with index
-r / --refresh adjust framerate/resolution to video

For me i'm going to use my HDMI to DVI cable to output video and standard 3.5mm for audio output. So i'm going to use the command.

sudo omxplayer -o local /My/Folder/MyVideoFileName.videoextension

If I was wanting to send my audio through the HDMI cable I would call something like this.

sudo omxplayer -o hdmi /MyFolder/MyVideoFileName.videoextension

And that's it, your 1080p Video will now run!! Please feel free to check out my other blogs or leave questions and comments below.

Useful Links
http://elinux.org/Omxplayer
https://github.com/huceke/omxplayer/blob/master/README.md

How to get Debian WORKING on my Raspberry Pi

2012-07-13T09:05:00.002-07:00

I ordered my Raspberry Pi in the first couple weeks that it was available, and after a 4 month wait because the demand was so high, it has arrived. So what is a Raspberry Pi and what are the first steps you should do to use it? Well the first thing I did was read lots of instructions. Why? you may ask. Well because these instructions are engineers speaking to engineers. Now if this was a standard tool, or TV, or something that people grew up using everyday then I wouldn't stress or waste my time reading any manual. this is different, so read the instructions!

A Raspberry Pi is one of my favorite deserts, and also the name of my newest electronic toy. It's ...

...called Raspberry Pi because it's a cool name. But actually its a complex little computer that is about the size of a debit card.

Broadcom chip that contains BCM2835 700Mhz CPU
GPU - Broadcom VideoCore IV - can run 1080p30 videos
256MB ram
Composite video, HDMI, 2x USB2.0, 3.5mm audio jack
SPI, I2C, 8x GPIO pins
B model includes Ethernet port 10/100

Requirements/Software

So lets get to business, first there are a few parts that you are going to need. First is a power cord with a micro-B connector. If you don't know what a micro-B connector is, then google it. Next you'll need some form of wall wort to power it, I used the one from my motorola phone. The important thing is that it has 500-1000mA of current and 5V. I also used a HDMI->DVI cable, a mouse and keyboard (low power ones work best). The last thing needed is an SD card, I used the one I got from Fry's for $5.

From your PC you can do one of two things when installing Debian, you can use windows or linux. Most my blogs are on linux but i'm going to use windows because I tried it and it worked great on my first try.

Download the debian file here------> FILE TO DOWNLOAD (443MB)

or go to http://www.raspberrypi.org/downloads for more downloads

Next you'll want to verify you downloaded it correctly so do a checksum on it. check for the following number.

SHA- 11852df83a11ee7083ca0e5f3fb41f93ecc59b1c8

If you don't know how to do a checksum, I would recommend some easy software ---> Checksum

Installation

So the next part is installing Debian onto your Raspberry Pi. I used a tool called Win32-image-writer. Make sure you go and download the binary version.

Once this is download you can run the tool. It looks like this:

You'll need to load the .IMG file from the debian download earlier. Then select your SD card in the device. Once you've done this press the write button and sit back and let it do all the work. Very easy!!

Load into the Pi

Now that the Debian image has been written to the SD card, put it in the Raspberry Pi. Hook up an Ethernet cable, HDMI, USB keyboard and mouse and connect the power!

The system will boot up and load for the first time, mine required a reboot once through the process. Once it has fully rebooted and is asking for a login, here is the default password and user name.

Username: pi
Password: raspberry

The system is essentially a Debian server with a few added packages. Now most people that are new to the world of Linux won't like the Terminal feel. This is where you will want to start the Graphical User Interface (GUI). To do this type:

startx

You should see it boot into this screen, and everything is up and running.

One of the last things you should do is update the system. To do this you need to update the list of updates by running:

sudo apt-get update

Then you will want to apply these updates by:

sudo apt-get upgrade

About 20+ minutes later your Raspberry Pi is up and running.

Also, once you boot you'll see a black border around your screen. Add the following to /boot/config.txt and this will fix that problem. Now this file didn't excist for me, so I had to create it first

cd~/
cd /boot/
sudo nano config.txt

add the following line:

disable_overscan=1

Thanks for reading my tutorial about how I got my Pi up and running. Please feel free to comment and ask questions below. I will be doing more tutorials about other features of the Raspberry Pi as time progresses.

Great reference sites:

http://elinux.org/RPi_Beginners
http://elinux.org/RPi_config.txt

Install Beagleboard XM Ubuntu 11.10 with GUI

2012-03-05T11:50:00.001-08:00

(LAST UPDATED 1/19/2013) - New blog that superseeds this one...in many ways check it out

So this quick run through will be to illustrate how to get Ubuntu 11.10 and a GUI running on the Beagleboard XM. Graphical User Interface (GUI, pronouced "Gu eee") is the interface that is used on most computers that does not consist of a Terminal or command prompt.

I do all my setup on my Windows 7 64-bit laptop (HP elitebook, i5 2nd gen). I have Virtual Box installed running Ubuntu Desktop.

One of the first things I install is VirtualBox Guest Additions Installations. This allows me to copy and paste between windows and virualbox. Go up to devices->install guest additions. It will prompt you for your Ubuntu root password. Then just wait. When finished reboot Ubuntu.

Lets begin...

USED Accessories:

Beagleboard XM rev C
SanDisk 8GB microSD
Sony SD to USB reader
Windows computer using virtual box, running Ubuntu 12.04 (Precise Pangolin)

Pre-reqs:
Before we begin we need to make sure we have all the required software on our main computer before we continue. Call the following command in your terminal.

sudo apt-get install wget pv dosfstools parted

Step One:

Identify your SD Card in Ubuntu once inserting it and bringing it into VirtualBox. Open the Terminal window and type the following.

df -h

You'll see something like the following, notice how my 4GB flash drive is referenced as /dev/sdb1 this is important and "sdb" will be used later.

Filesystem Size Used Avail Use% Mounted on
/dev/sda1 6.1G 3.8G 2.1G 65% /
none 943M 652K 942M 1% /dev
none 949M 1.1M 948M 1% /dev/shm
none 949M 100K 949M 1% /var/run
none 949M 0 949M 0% /var/lock
/dev/sdb1 3.7G 32K 3.7G 1% /media/5DA5-2520

Next you'll want to download the following stable release of Ubuntu for the Beagleboard Xm with the following command. Also, it's about 108MB so it might take a little time to download on your virtualbox or ubuntu host, i'm using virtualbox.

wget http://rcn-ee.net/deb/rootfs/oneiric/ubuntu-11.10-r10-minimal-armel.tar.xz

Once that has downloaded you want to verify that the download was successful, we do this with whats called a checksum. This is an advance algorithm that spits out a number that can be compared to verify the download was sucessful. To do so type the following by typing:

md5sum ubuntu-11.10-r10-minimal-armel.tar.xz

You must get a result that matches this!

0221ef5b014097a6a42796e54c7c365c ubuntu-11.10-r10-minimal-armel.tar.xz

Since this is a TAR file, similar to a ZIP in windows so we must extract the files and than go to that directory

tar xJf ubuntu-11.10-r10-minimal-armel.tar.xz
cd ubuntu-11.10-r10-minimal-armel

Now that you're in the right directory its time to call the script that will partition and setup all the files on the micro SD card. Now this part its important to remember the drive name that we did above, "sdb" as this is substituted into the command below.

sudo ./setup_sdcard.sh --mmc /dev/sdb --uboot beagle_xm

Mine is taking about 10 mins to setup, this may vary.

After this is complete go into the disk utility found at System -> Administration ->Disk Utility, and make sure you unmount and Safely Remove the drive (MAKE SURE YOU DO THIS EVERY TIME).

Step Two:

Now that Ubuntu has been installed on your Beagleboard XM you can test it by inserting it into the beagleboard Xm and starting it up.

NOTE: Default username: ubuntu Password: temppwd

To check the kernel version type the following once it's booted up.

uname -r

At the time of this writing mine is version 3.1.6-x6 , now to check the version of Ubuntu type

lsb_release -a

Step Three:

Now you should have Ubuntu 11.10 installed but you will be missing the Graphical User Interface (GUI). In our case there are many options for user interfaces to install on that can be used but we're going to use XFCE because i've found it works well. Others many be used. Call the following commands to install the GUI.

sudo apt-get upgrade

sudo apt-get install gdm xfce4 xserver-xorg-video-omap3 network-manager

This may take a while to update and install, could take an hour! Once its all installed reboot and log into your new GUI Ubuntu on the Beagleboard XM!

(image may look different on BB)

If you have problems getting the Ethernet working on bootup try the following commands:

sudo ifconfig -a
sudo dhclient eth0
sudo ifconfig -a

Please leave feedback or email me questions.

Python controlling SPI Bus on Beagleboard XM, and Raspberry Pi

2012-02-26T16:53:00.002-08:00

UPDATE: 8/6/2012 - works for Raspberry Pi too, enjoy!

So i'm writing my second article on how to do stuff on the Beagleboard Xm. This time i'm going to focus on how to write python code to control the Beagleboard Xm SPI bus ports.

Most the time I could stick with programming C since my last posts required doing a SPI test that comes when you compile the kernel and test the ports. Coworkers I work with use Python on a daily bases so I figured this would help since my next goal is to write a GUI application that has different SPI commands or inputs and seems simple enough to do with Python. So Python here we come.

I'm going to start from the beginning and then include a download link of my final files to help you along the way.

Step One
It's important to understand that you have access to the hardware that you're looking to control. So before we move forward make sure you have on your bealgboard access to a spidev. This can be checked by going into the /dev/ folder and looking for spidev3.0 or such.

cd~/
cd /dev/

Look and see if you see something along the lines of spidev3.0 or spidev3.1 or spidev4.0, if you don't please refer to my older post where I walk through patching the kernel and getting to this stage. Getting SPI working on the Beagleboard XM.

Step Two
Next its important to have some understanding of Python. Now if you're completely new to this like I am than taking Google's Python Class will really help you out. It's a two day class that may take you longer as it did me (time restraints), but you'll learn a lot of basic information that should get you going on the language.

Step Three
Ok, now we can start with communicating with the /dev/spidev3.0 device that is our SPI port on our Beagleboard XM. The first thing I read through was the C example that was provided by Kernel's Documentation on SPI. There are a few things that are very important so lets first make sure we have the right packages installed so we can do Python programming.

sudo apt-get install python-dev

Now that the right packages are installed on your Beagleboard XM let's take a moment to figure out how we want to go about controlling it. The methods I came up with were either one, figure out the right commands that are comparable to C and get them working in Python. Two, make a C module that could be called anytime in Python and passed in a string of Hex values.

Honestly I really liked option two so this is what i'll be demonstrating. This whole process was not easy as I searched much of the web trying to figure out strategy of examples and blog posts and such. Once again here I am leading you to understand what I've found. So the first thing to understand about passing a C module into Python is its very similar to a DLL for windows. We will have a module that has a list of function that can be called from our Python variable and will transfer our data. My Goal is to take in a Python string like this and get a C hex like the following.

Pyhon String Input:
data = ["FFFF40009545"]

C Hex output:
uint8_t list = {0xFF, 0xFF, 0x40, 0x00, 0x95, 0x54, 0x45};

The reason for wanting to do this is simplicity. There may be better options and if so I would love to hear about them. Add a comment at the bottom of this post please!

To do the transformation there must first be a C program that takes in both the string data and the length of string. This will guaranteeing the data is being parsed out right in C as it was expected in Python. My Python test file I'll call spitest.py and it will have something along the following lines on the Beagleboard Xm.

(click to enlarge)

Click here to download >>> spitest.py

As you can see in spitest.py there are a few commands that are called out, such as spi.SPI, transfer, and close. These are the three main commands i'm centering my C module around and will be the ones I call out and use in Python. One opens, one transfers the data, and one closes the SPI port. When the time comes to test this I'm going to place this test file in the following directory that should be created after I compile spimodule.c. It's important to have the testing file in the same directory for now as the compiled spi.so file. It's also important to have the "import spi" which will import into our python code our spi.so module we are going to create in the future steps.

/home/ubuntu/build/lib.linux-armv7l-2.7

Then when the time comes I'll call the following command to run my test from that directory.

sudo python spitest.py

Step Four
Yes I know like this feels like we're going back a step but I had to explain the python first. So now we're going to create the spimodule.c file that will do the conversion of the incoming string to a hex value that can be transferred to the hardware.

To do so there has to be a understanding of two things one, how to convert from a string to a hex and two how to write an extension module. Neither are easy if you're a novice programmer like myself. As much as I like to go into details, i'm not going to cover how to write a extension module for Python. More info on that can be found here Python Documentation for writing extensions. Great examples can also be found at Tutorials Points. The original code I found and edited and based my module from is documented here.

Within this spimodule.c that is being used is the following code I wrote that allows for the conversion as well as documents much of the code to transfer the data.

(click to enlarge photo)

Download the full module here at >>> spimodule.c

This code is the transfer function (not differential equations kind), but the one what will transfer our SPI data. It takes the string parses out the first two characters and saves them into a variable called hexbyte. Then using sscanf and scans it into a uint8_t type as a hex value using %X. Here is a table to explain the different sscanf formats and how to pass in different value types.

(click to enlarge)

A good rule of thumb for helping with debugging and using different types of parsing and type conversion is to print your results and to separate them in your code so you can keep track and debug it later. You can see in my code that I often do printf so that I know where my data is and what it should be.

Step Five
Now that my spimodule is made and should be working lets build it and run everything. Feel free to try my files above but note they are there for advice not to be your secure work around.

NOTE: THERE IS NO ERROR CHECKING IN THE CODE

So the first thing to do is to compile the code. I have my spimodule.c and a setup.py file located in my main home directory. The setup file is used as a compiling file that calls the C file and any other extension or author notes that are needed.

Download into home directory with spimodule.c >> setup.py

cd~/
sudo python setup.py build

This will build your spi.so file and it will be located in the following folder. If it isn't this is because it was built somewhere else and after building it it will tell you were it is located. There may be some warnings when you compile it but thats ok, as long as there aren't errors.

cd build/lib.linux-armv7l-2.7

check the directory,

ls

You should see a file spi.so and this is where you'll place your spitest.py from step three. Now lets run the spitest.py. One thing to mention is I setup the spimodule.c that got compiled into the spi.so to give some printf functions for every 2 hex value both as a string and later when it is type casted into a unsigned integer 8-bit size.

sudo python spitest.py

You should get a result like this:

(click to enlarge)

As you can see the string has been passed, and separated and then converted to Hex format. Then the data shows you what is going to be sent and what is received. If they are the same, than everything is a success. Now go on and program Python to pass your data to SPI bus devices!

NOTE: make sure you have a wire across the MOSI and MISO pins on the beagleboard xm.

Please leave comments, feedback, or code corrections!!

Bibliography

String to Hex example
http://forums.devshed.com/c-programming-42/convert-char-string-to-hex-format-586165.html

Other good links
http://www.nerdkits.com/videos/printf_and_scanf/

https://wikis.oracle.com/display/DTrace/Types,+Operators+and+Expressions

http://www.cplusplus.com/reference/clibrary/cstdio/sscanf/

GREAT EXAMPLE OF IMPORTING C as a module
http://en.wikibooks.org/wiki/Python_Programming/Extending_with_C

http://www.tutorialspoint.com/python/python_further_extensions.htm

http://docs.python.org/extending/newtypes.html

Code examples python
http://elk.informatik.fh-augsburg.de/da/da-49/trees/pyap7k/lang/

Kernel Documentation Spidev
http://www.kernel.org/doc/Documentation/spi/spidev

http://www.kernel.org/doc/Documentation/spi/spidev_test.c

Google Python Class
http://code.google.com/edu/languages/google-python-class/

SPI working on the Beagleboard XM rev C

2012-02-04T13:48:00.000-08:00

(UPDATE 1/19/2013) - NEW blog post on installing Ubuntu 12.10, includes enabling SPI and more click this link BLOG POST

(UPDATED 7/5/2012) - (added ubuntu-11.10-r3 download from dropbox, as original source no longer exists.)

So this is for people that are trying to get SPI working on their Beagleboard XM rev C boards. At the time that I began this adventure I had no clue how to get SPI working on my board. So I decided to blog about it while I was learning, and now it works. The setup is for Ubuntu 11.10 and using Kernel v3.1.10 So let me share with you.

Now you must understand I've spend much time looking at many different posts on the google group "beagleboard", many blog sites, elinux pages and such. People are just ripping their hair out as someone put it on how to successfully get SPI working. What I found was skattered knowledge of the topic and I wanted to bring it all together for the novice user.

There is something else you should know about me and that is i'm a novice user in the Linux world. In my search I was really searching for was a straight forward walk though from starting to finish, starting with a blank 4GB microSD card and ending on getting SPI working.

So lets get started from the beginning....

USED Accessories:

Beagleboard XM rev C
SanDisk 8GB microSD
SD to USB reader
Windows computer using virtual box, running Ubuntu 11.04 (Natty)

Step One:

Identify your SD Card in Ubuntu

df -h

You'll see something like the following, notice how my 4GB flash drive is referenced as /dev/sdb1 this is important and "sdb" will be used later in many different cases:

Filesystem Size Used Avail Use% Mounted on
/dev/sda1 6.1G 3.8G 2.1G 65% /
none 943M 652K 942M 1% /dev
none 949M 1.1M 948M 1% /dev/shm
none 949M 100K 949M 1% /var/run
none 949M 0 949M 0% /var/lock
/dev/sdb1 3.7G 32K 3.7G 1% /media/5DA5-2520

wget http://rcn-ee.net/deb/rootfs/oneiric/ubuntu-11.10-r3-minimal-armel.tar.xz

(UPDATE - THE ABOVE DOWNLOAD NO LONGER WORKS, PLEASE SEE FOLLOWING LINK FOR FILE) Be sure to place this in the standard home directory like before. Then continue procedure.

wget https://dl.dropbox.com/s/c5jc16rdqnjglw3/ubuntu-11.10-r3-minimal-armel.tar.xz?dl=1

md5sum ubuntu-11.10-r3-minimal-armel.tar.xz

You must get a result that matches this!

551e66185c5ce3c6270a8e38b8ac6457 ubuntu-11.10-r3-minimal-armel.tar.xz

Since this is a TAR file, similar to a ZIP in windows so we must extract the files and than go to that directory

tar xJf ubuntu-11.10-r3-minimal-armel.tar.xz
cd ubuntu-11.10-r3-minimal-armel

Now that you're in the right directory its time to call the script that RCN-EE (Robert Nelson) made what will partition and setup all the files on the micro SD card. Now this part its important to remember the drive name that we did above, "sdb" as this is substituted into the command below.

sudo ./setup_sdcard.sh --mmc /dev/sdb --uboot beagle_xm

Step Two:

Now that Ubuntu has been installed on your Beagleboard XM you can test it by inserting it into the beagleboard Xm and starting it up.

NOTE: Default username: ubuntu Password: temppwd

To check the kernel version type the following once it's booted up.

uname -r

At the time of this writing mine is version 3.1.6-x6 (This changes to 3.1.10-x7 by the end of the procedure), now to check the version of Ubuntu type

lsb_release -a

SPI BACKGROUND
Now a little bit of SPI background knowledge is needed in order to get this working. First off Serial Peripheral interface (SPI) is made up of 4 wires normally. It is a standard that was designed by Motorola for use with their micro controllers. If you're interested in learning more about SPI i've added the Wikipedia link in the bibliography below. Here is what a standard SPI setup looks like, multiple slaves is optional.

SS - Slave Select (Beagleboard community calles this Chip Select (CS))
MOSI - Master Out Slave In
MISO - Master In Slave Out
CLK - Clock

On the Beagleboard XM there are 4 SPI controllers that come with the processor, but only two of them have been brought out to be used in the hardware, these are McSPI3( I will be using) and McSPI4. I've written up a small table in excel to demonstrate this information (details came originally from BB XM manual).

It will be important later when we're testing the test program that we have the right pins connected. We'll connect pins 17 and 19 of the output pins MOSI into the MISO

Step Three:
So now we've made it to the point of needing to setup the SPI pins in the Kernel. Everything i've learned is from a combination of time, searching all over the internet and a couple discussions with Robert Nelson and reading through lots of his scripts.

Now from my reading there are two main parts that have to be changed. The first is the PIN MULTIPLEXER, the second is configuring the SPI_BOARD_INFO. Most of this is skipped and done automatically through scripts we'll be using but its good to know whats going on. More information can be found at http://elinux.org/BeagleBoard/SPI if you're interested.

First there are a bunch of tools you need in your Ubuntu environment. These include the ARM compiler and the Git tool, uboot tools and more, you'll understand as we progress. So lets install these ( virtualbox Ubuntu):

sudo apt-get install gcc-arm-linux-gnueabi git
sudo apt-get install ccache libncurses5-dev u-boot-tools

Next we need to download the latest version of Ubuntu with the SPI patch

git clone git://github.com/RobertCNelson/stable-kernel.git
cd stable-kernel
git checkout origin/v3.1.x -b v3.1.x

Now before we continue we have to un-comment the following line by removing the "#" symbol. Save the file and we'll continue to to the building.

gedit build_kernel.sh

Un-comment,

#patch -p1 < ${DIR}/patches/beagle/0001-spi-testing.patch

NOTE: you might have to copy the system.sh.sample file to system.sh like I had too.

cp system.sh.sample system.sh

Now you have to un-comment a line in system.sh by removing the "#" symbol. Save it and continue.We will come back to edit this file more later, so keep note where it is and read through it if you have time. As this file holds the MMC directory for when we're using the load uImage script.

gedit system.sh

#CC=arm-linux-gnueabi-

In order to compile the kernel you have to first have all the basic Linux kernel files. To do this we must have the following files. By typing in the following, it should take a while (~500MB):

cd ~/
git clone git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git

After this is complete we are ready to compile the kernel, make sure you go back to the stable-kernel directory before you build the kernel.

cd~/
cd stable-kernel
./build_kernel.sh

During this time it will change from a default terminal screen to a select screen that looks like the following.

Once your to the Kernel Configuration menu scroll down to the "Device Drivers" then go to "SPI Support" and than make sure the following are selected.

[*] Debug support for SPI devices
[*] McSPI driver for OMAP
[*] User mode SPI device driver support

After you Exit it will ask you to save, do so. Then it will continue to install for about an hour or more depending on your system speed.

Once the creation of the Kernel has been complete run the following line to apply this to the microSD card.
Two things have to be done before this can be done. First you have to edit the system.sh file again. Make the following adjustments according to your drive letter like the beginning of this article (/dev/sdb)

cd ~/
cd stable-kernel/
gedit system.sh

CHANGE the MMC and un-comment "#" in front of the ZRELADDR:

MMC=/dev/sdb

and

ZRELADDR=0x80008000

If you desire to go into board-omap3beagle.c located in KERNEL you can change some of the default settings and then apply this patch.

Note: you'll need to recompile the kernel afterwords I believe. I didn't have to update, this was advice from Robert.

git diff > ../patches/beagle/0001-spi-testing.patch

Now the last step is to load all the files to the microSD card, make sure you're in the /stable-kernel/ directory still:

. ./tools/load_uImage.sh

After all the loading is done safely remove the flash card from your computer and load it into the Beagleboard Xm. Once everything is loaded up you should be able to change directories to the /dev/ and see your spidev3.0 and spidev3.1 device names there now.

Step 4

Time to test this code and and see that everything works. To do this i'm going to load my microSD card back into virtualbox and test the ports. To do this we need to reference the table for the pins above and connect pins 17 and 19 which are SPI3.0 MOSI and MISO. They look like the following on the back of the board (MARKED IN RED DOTS).

Once back in virtualbox using the terminal go to the following directory and compile the SPItest example.

cd linux-stable/
arm-linux-gnueabi-gcc Documentation/spi/spidev_test.c -o spitest

Once this is created, move the "spitest" to the main directory of your microSD card where Ubuntu is running, normally found in the /home/ubuntu area.

Now un-mount and safely remove the flash card, hint, like you always should be doing. Insert back into the Beagleboard Xm and bootup. Once you've logged in run the following command to check if SPI is now working.

./spitest -D /dev/spidev3.0

You should see a result like this.

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0x40, 0x00, 0x00, 0x00, 0x00, 0x95,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD,0xF0, 0x0D,

If you didn't hook up the right pins on the beagleboard xm you'll see something like this

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF,

If you saw the first set of data above then you've completely setup SPI correctly. Congrats!!

(Probing the Beagleboard Xm with digital channels of Tektronix Scope)

(Here is my whole setup probing the Beagleboard Xm with a Tektronix MDO4104-6)

(screen capture from MDO4104-6 Mixed domain Oscilloscope showing decoded SPI signal)

As you can see I'm decoding the channels from the BBXm and i'm getting the correct SPITEST signal. This has been the final verification that i'm seeing both the Clock, MOSI and SS pins working. Sweet!!

If you liked my demonstration please leave feedback and pass this along.

Bibliography

Here are a few useful links I used during this process...

Helpful information on GIT commands and how things work:
http://stackoverflow.com/questions/67699/how-do-i-clone-all-remote-branches-with-git

Good reference blog for Angtrom SPI setup:
http://linuxdeveloper.blogspot.com/2011/10/enabling-spi-on-beagleboard-xm.html

Wikipedia SPI details (I added if you wanted to learn more):
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus

Elinux:
http://elinux.org/BeagleBoardUbuntu

http://elinux.org/BeagleBoard/SPI

http://elinux.org/BeagleBoard/SPI#Little_Word_about_recompiling_the_Kernel

Beagleboard Manual:
http://beagleboard.org/static/BBxMSRM_latest.pdf

General Linux, full detail SPI kernel compile:
http://www.jumpnowtek.com/index.php?option=com_content&view=article&id=57&Itemid=62

2012-01-30T11:59:00.000-08:00

So for work we've got a Superbowl party coming up this Friday, we're going to have a chili cook off and a finger football competition. This party will be for just over 100+ people. Being a part of the "fun committee" I was in charge of creating the goal posts that people would be kicking their paper footballs through. At first I was thinking of something simple, maybe 1.5 feet tall. But than I realized I could do this so much better. So here is a picture of what i've come up with. It stands 3.8 feet tall and there will be a movable cart that we'll have different distances for levels of the kicking competition. After three rounds we will declare a winner. I'm sooo excited for this Friday!!

Ya that's right! this thing rocks!

Cheers,
Brian

2012-01-28T15:21:00.000-08:00

To the world of blogging and beyond. Not much is known about why people share their thoughts in such an open atmosphere. Think about it, people like you and me, sharing thought to strangers. Complete strangers, probable sitting at home in a country far away even. What is wrong with people! Why don't people get up off the couch and go to the gym or get a life of their own instead of reading about others they wish they knew? None the less, I begin my own.

So where do I start? Do I talk about the weather, sports, my job, personal achievements, projects, the topics can go on forever.

Currently I've started a new project that my wife probable thinks takes up too much room in our little one bedroom apartment. Taking up all of our desk space and sometimes leaving a mess. None the less it's good to have a project. Something to be constantly pushing your mind, skills, and effort towards. It doesn't matter how small or large your project idea is, what matters that it's pushing you towards your goal. Being creative, engineering, and keeping your mind sharp is very important, it leads to living longer. No I won't go into details about my project, might be a business one day. But the idea behind keeping your mind sharp can be very important.

2012-01-20T11:24:00.000-08:00

My first post on brianhensley.net

Cheers,

~Brian