After two weeks of working with it I got bored of reading the BeagleBone manual over and over every single time I had to use a pin so I created this “pin layout cheat sheet” that can be printed and hung on the wall.

Enjoy!

1. I do not know anything about ‘programming’
2. I do not know anything about networking (aka tha intaRwebz)

It turns out this is a fairly easy project using a new programming language called Node.js.  Node.js ships with the Beaglebone, so all that is needed is to update it with some new libraries.

# npm install socket.io

# npm install serialport@1.0.3

The first one is a library for making connections between computers, called sockets.  The second one gives node.js the ability to read and write to serial ports in the /dev/ folder.  The newest version of the serialport package was broken, but by adding the @1.0.3, the package manager installs an older version.  With these libraries, the code to make the ethernet-serial converter is pretty slim.

var net = require(‘net’);
var SerialPort = require(“serialport”).SerialPort

var serialPort = new SerialPort(“/dev/ttyO0″ , { baudrate: 115200 } );

var server = net.createServer(function (socket) {

socket.on(‘data’, function(data) {
console.log(data);
serialPort.write(data);
});
});

server.listen(8080, ’192.168.1.145′);

This goes in a file, called app.js, then can be executed with a short command.

# node app.js

And that’s it, it starts and echoes whatever TCP data comes in on port 8080 out serial port 0.  I tested it using a program called “TCP Test Tool”, from a company called Simple COM Tools.  You can see in the screenshot, the lower PuTTY window is the serial connection to the Beaglebone.  The upper PuTTY window is the ethernet connection.  On the left is TCP Test Tool 3.0.

This rover was our robot in the competition of Magyarok a Marson 2011 (Hungarian on Mars). The competition was similar to a capture the flag game, with four rovers on the field at the same time.
We weren’t that experienced that time (and our budge was low) so the project failed. We were good in the first round but unfortunately at the second round some smoke has been made and the motorcontroller went to the robo-heaven. Also we smoked an 25A car fuse, yeah something was very bad in our design. We didn’t have the automatic control in time so we used the manual version. In this case we had to use 15 sec delay between two command to follow the rules. We started the blog roughly after two months to the competition. Here is a picture of the rover at that time.

After some talk we took action, and used Bence’s motor controller. It’s double channel so we can control 2 different motors completely but we plugged each side (a pair of motors) to each control so this way we can use four motors instead of just two.
Here are the videos and pics:

Too fast, one wheel went away
Testing the prototype controller
part 2

The motors are 24V. The motorcontroller is from ebay you can check one of it’s successors on the link below:

http://www.ebay.com/itm/High-Current-Stepper-Dual-DC-Motor-Driver-Module-PWM-Signal-Control-Board-/320967349902?pt=LH_DefaultDomain_0&hash=item4abb25168e

The BeagleBone was above all: wifi support, motor control, web interface.

The hardware consists of a lipo battery (5400 mah, 14,8v, serves a lot better than the 11.1V version), voltage stabilizator, motor controller, BeagleBone, wifi stick, usb hub, webcam.

Meet the revived rover: Firebug!

( http://en.wikipedia.org/wiki/Firebug)

In action:

BeagleBone A6

Product Description

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

BeagleBone A6 Feature

• http://specialcomp.com/beagleboard/bone.htm
• http://beagleboard.org/bone
• http://beagleboard.org/static/beaglebone/a3/README.htm
• free 4GB class 4 microSD test card and SD adapter
• free USB Mini-B device cable

BeagleBone A5

Price: Click to See Best Price!
Product Details: Click to See Product Reviews & Ratings

Select Your Location: United State | Canada | United Kingdom

BeagleBone A5 Related Articles

Tags: BeagleBone A5

BeagleBone A5 Related Products

BeagleBone A5 Price: See Prices Product Details: See Product Details Select Location: United State | Canada | United Kingdom

SHOW ALL RELATED PRODUCTS FROM AMAZON.COM >>

This blog is a participant in the Amazon Services LLC and Amazon EU Associates Programmes, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to Amazon.com, Amazon.co.uk, and Amazon.ca.

PWM probably comes from communications but what it essentially is is a square wave (No, the double is was not a typo!). Well, not exactly a square wave… But imagine this. Take a square wave like this one:

Now, keep the rising edge at the same position each time and only move around the falling edge between the previous and the next rising edge. That is PWM for you! Basically, you’re modifying the width of the pulses but you keep the time period constant. That means a PWM signal has a characteristic frequency which is kept constant because if it were to be modified, it wouldn’t be called PWM but rather Pulse Position modulation (PPM – The digital analog of frequency modulation) but we don’t need to get into that! A PWM signal looks like this:

There are different ways in which PWM can be produced. In the image above, you can see that he takes the point at which the triangular wave cuts through the input signal for both sides of the pulse. In other cases, only the rising edge is used for syncing and the pulse starts agains after the signal is over. In this kind, a sawtooth signal as opposed to a triangular wave. The duty cycle of a PWM signal is the ratio of the ON portion of the wave to the whole time period. In our case, we will use a constant duty cycle in the short scale and vary it when we need to.

So that’s the basics of PWM. Now what is it used for? With digital controllers, it is difficult to produce an analog voltage. You need to work with DACs (Digital to analog converters) and it is generally a pain to use. Another problem with DAC is that sometimes, like when you’re controlling an LED, it is current controlled and has a threshold voltage. Since it is current controlled, you lose some power on the resistor you put in series to carry the extra voltage drop. What you do instead is use a PWM signal. If you take a high enough frequency (Even 50 Hz would do) and you use the PWM signal to control a transistor switch (Which in turn controls your load, in this case the LED), an averaging effect occurs and the LED brightness can be varied easily by changing the duty cycle. With this, you can have very low duty cycle which can achieve very low brightness which cannot be done with a voltage controller. Awesome, right?!

With respect to quadrotors, how is it used, you say. Well, I may get into the working of the BLDC (Brushless DC Motors) in a later post but basically it takes three sinusoidal inputs which are 120 degrees out of phase with one another. This is fairly difficult to generate, especially because the currents are insanely high. So what we do is use an ESC (No, not escape, Electronic Speed Controller). These are high power devices which take a 12V input and provide three output wires to connect to the motor. Easy enough. Just match them up. Be careful about the polarities (Two will be opposite – Again, I’ll post about this in a later post). So how do you control the speed? You cannot directly vary the voltage, especially because the power is so much.

Generally, ESCs are programmable and require a PWM input to control the speed. For example, in my ESC, by varying the frequency from 50Hz – 60Hz you fix the frequency at some value between 50-60Hz and vary the duty cycle from 1ms-2ms to set the speed. At 1ms, the motors will be off and 2ms, it will be maximum. For initial tests, I was using something like 1.2ms. Apparently, this is the perfect format for radio controllers but using a microcontroller has the same effect. I would suggest using a circuit in between, just to be safe. I haven’t done that with this microcontroller yet because I was working on using the PWM modules on the Beaglebone itself. Here’s how it works:

There are three enhanced high resolution PWM modules (ehrpwm). Each has two outputs. The duty cycle of the two outputs can be different but they both have to be at the same frequency and the same run state. This posed a problem because I only had access to three outputs of which I could control the frequency! Well, let’s trying using them anyway (Hmmm… What is that itching sensation up my sleeve?) That means each PWM module can control two motors each giving control over a total of 6 motors.

First, the mux settings have to be adjusted to allow the PWM output to be provided at the particular pins as shown below. The first module is called the ehrpwn.0
The two pins are denoted as ehrpwm.0:0 (Pin P9-31) and ehrpwm.0:1 (Pin P9-29) respectively. Those are the pin numbers where the output will appear. Here is what you have to do.

root:~# echo 1 > /sys/kernel/debug/omap_mux/mcasp0_aclkx
root:~# echo 1 > /sys/kernel/debug/omap_mux/mcasp0_fsx

If you want to use the second module: ehrpwm.1:0 (Pin P9-14) and ehrpwm.1:1 (Pin P9-16) respectively:

root:~# echo 6 > /sys/kernel/debug/omap_mux/gpmc_a2
root:~# echo 6 > /sys/kernel/debug/omap_mux/gpmc_a3

For the third module: ehrpwm.2:0 (Pin P8-19) and ehrpwm.2:1 (Pin P8-13) respectively:

root:~# echo 4 > /sys/kernel/debug/omap_mux/gpmc_ad8
root:~# echo 4 > /sys/kernel/debug/omap_mux/gpmc_ad9

I got all this information from the datasheet. You can go through it in detail. Note that the first module can be obtained at a second set of pins if you want.

After doing all this, the PWM settings are directly exposed in the file system. The main ones we will be dealing with are: period_freq (Frequency in Hz) and duty_percent (Duty cycle)

We covered both of these features in the intro section. Make sure the duty_percent is set to 0 before changing the period. Otherwise, it is said that the duty_percent may be randomly changed to a different value. If i and j define the PWM module and the output:

root:~# cd /sys/class/pwm/ehrpwm.i:j
root:/sys/class/pwm/ehrpwm.i:j# echo 1 > request
root:/sys/class/pwm/ehrpwm.i:j# echo 0 > duty_percent
root:/sys/class/pwm/ehrpwm.i:j# echo 1 > period_freq
// Sets the duty cycle in percent
root:/sys/class/pwm/ehrpwm.i:j# echo 50 > duty_percent
or
// Sets the duty cycle in nano seconds. Use either
root:/sys/class/pwm/ehrpwm.i:j# echo 1000000 > duty_ns
root:/sys/class/pwm/ehrpwm.i:j# echo 1 > run

For example: root:~# cd /sys/class/pwm/ehrpwm.0:0

It is good to check the availability of the PWM pins first through the following command.

root~:/sys/class/pwm/ehrpwm.i:j# cat request
ehrpwm.i:j is free

period_freq is directly in hertz while the duty_percent is in percent. The polarity is also useful to invert the logic.

Easy enough, right? Beats embedded C any day of the week and twice on Sunday! (Stole that from some movie )

So what about that fourth motor!! So what about that extreme case you want to control 8 motors? Do we just pair up two motors, sacrificing mobility?

NO!! There is another module which can be used as a PWM called the ecap module, short for enhanced capture. The procedure to use it is very similar to that of the ehrpwm. The AM3358 has three ecap modules but the Bone implements only two of these. These are the mux pins for the two different ecap modules:

For ecap1 on P9-42

root:~# echo 0 > /sys/kernel/debug/omap_mux/ecap0_in_pwm0_out

For ecap2 on P9-28

root:~# echo 4 > /sys/kernel/debug/omap_mux/mcasp0_ahclkr

And then, almost the same set of commands as for ehrpwm (With the addition of one extra command)

root:~# cd /sys/class/pwm/ecap.i
root:/sys/class/pwm/ecap.i# echo 1 > request
root:/sys/class/pwm/ecap.i# echo 0 > duty_percent
root:/sys/class/pwm/ecap.i# echo 1 > period_freq
// Sets the duty cycle in percent
root:/sys/class/pwm/ecap.i# echo 50 > duty_percent
or
// Sets the duty cycle in nano seconds. This is for 1ms on time Use either
root:/sys/class/pwm/ecap.i# echo 1000000 > duty_ns
root:/sys/class/pwm/ecap.i# echo 1 > run

Where i is either 0 or 2 (Those are the ones that Beaglebone implements).

So to summarize what the Beaglebone can do in terms of PWM: There are 3 independent ehrpwm modules, each of which has two outputs. The outputs of one module must have the same frequency but can have different duty cycles. This gives you 6 output pins. There are two ecap modules which can be used for PWM. These modules are independent. That gives you a total of 8 PWM pins to play with…
Enjoy! Just don’t connect your loads directly! LEDs may be okay with a resistor in series but if you’re not sure, follow a tutorial or use a transistor switch to protect the board.

So that’s it for today. As always, if you need some help with this, feel free to post in the comments.

Check it out here:

https://github.com/alexanderhiam/PyBBIO

lsusb

Now you should see that the webcam is attached to the system and works fine as a hardware. Here is what you might see:

root@beaglebone:~/mjpegstreamer/mjpg-streamer# lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 006: ID 0ac8:301b Z-Star Microelectronics Corp. ZC0301 Webcam
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
lsmod

to see the kernel modules loaded well, here is what you might see:

root@beaglebone:~/mjpegstreamer/mjpg-streamer# lsmod
Module                  Size  Used by
keucr                  48946  0
gspca_zc3xx            35649  0
gspca_main             14527  1 gspca_zc3xx
spidev                  3888  0
ip_tables               7830  0
x_tables               14348  1 ip_tables
g_mass_storage         24026  0
rfcomm                 24259  0
ircomm_tty             14073  0
ircomm                  8407  1 ircomm_tty
irda                   85557  2 ircomm_tty,ircomm
hidp                   10152  0
bluetooth             109714  4 rfcomm,hidp
rfkill                 14605  2 bluetooth
ipv6                  210466  16

the two importatnt:

gspca_zc3xx            35649  0
gspca_main             14527  1 gspca_zc3xx

And one last thing,

ls /dev/

if there is video0, then everything is fine to go to the next step.

You have to dowload the mjpeg-streamer from here.

After you extracted the files, all you need to do is give

make

command.
When it’s finished with compiling then, you have to start the mjpegstreamer.

./mjpg_streamer -i "./input_uvc.so" -o "./output_http.so -w ./www"

or see the start.sh inside the mjpg-streamer dir for more tips of using it.

Now use a web browser, beaglebone-ip:8080/ (eg.:http://192.168.0.22:8080/)
If everything is fine you can see the webcamera image.

References:
openwrt
http://yetanotherhackersblog.wordpress.com/2010/11/20/streaming-uvc-webcam-video-over-802-11n-with-a-beagleboard/

The outcome of this tutorial will be a webpage that looks like this:

After a bit of googling around I found out that there are plenty of light-weight html frameworks working from python, javascript, and various technologies.

I chose a framework called pico.

https://github.com/fergalwalsh/pico/wiki

Execute these steps on the BeagleBone:

git clone http://github.com/fergalwalsh/pico.git
opkg install python-distutils
opkg install python-compile
cd pico 
python setup.py install

This should install pico on your BeagleBone. Now you can cd into an example directory and try it out!

cd examples/helloworld
python -m pico.server

Now you can play a bit with the example and then I’ll continue.

…

Finished already? Let’s continue with putting something actually working behind the web interface.

****

If you don’t have any idea what to do for a start use this led blinker script below. I’ll create a script to send commands to my Arduino.

wget http://gigamega-micro.googlecode.com/files/gpiotester.py

Since I have an Arduino behind the BeagleBone for now I’ll have to communicate with that through serial port.

Let’s get and install pySerial.

wget http://pypi.python.org/packages/source/p/pyserial/pyserial-2.6.tar.gz
tar -xf pyserial-2.6.tar.gz
cd pyserial-2.6
python setup.py install

Easy isn’t it?

So now that we have a Serial class we can communicate with the Arduino from the BeagleBone using Python.

I wrote the script below to control the robot. Yeah, it’s not too elegant but will do for now.

http://buggers.svn.sourceforge.net/viewvc/buggers/robots/scarabeus/beaglebone/webcontrol/beagle2arduino.py?view=markup&pathrev=336

Note that I’m using string commands so I’m sending strings directly to my Arduino.

Now that we have something to call from a webpage, let’s create the page itself!

You should check out the codes in the example folder to get the hang of the framework, it shouldn’t take too long.

This is what I came up with in the end:

http://buggers.svn.sourceforge.net/viewvc/buggers/robots/scarabeus/beaglebone/webcontrol/index.html?revision=325&view=markup

Note: if you are experiencing some kind of lag or blocked messages, you can help it by running the following on the BeagleBone. This “wakes up” the serial port. The above python code of mine will require a bit more massage to get this effect.

screen /dev/ttyUSB0

And finally here’s a video of controlling my rover using the above web page:

Like if you like my whistling and of course comments are always welcome!

References

http://pypi.python.org/pypi/pyserial

http://www.mediacollege.com/internet/javascript/form/add-text.html

https://github.com/fergalwalsh/pico/blob/master/examples/helloworld/index.html

http://www.w3schools.com/

I started working on a project which require communication with multiple radios. I started looking at nRF24L01 chip and found it to be very useful, cheap little device which has many features built-in. Initially I got two AVRs to talk to each other through the simple library found here (http://www.tinkerer.eu/AVRLib/nRF24L01). But I found multiple issues with the library when the number of nodes in the network increases,

• Didn’t support retries
• Dynamic packet sizes
• Channel scanning, etc

It was a simple library to start with and understand how the radio actually works in different configurations. I didn’t want to spend lot of time implementing all features I wanted so started looking around for complete libraries for nRF24L01, and I found RF24.

RF24 is one of the most complete libraries available for the nRF24L01[+]. So I implemented my project using RF24, It was an excellent library for AVRs (Arduino), but there was no port for devices running linux, as one of the nodes in my network was running linux I had to hack the code in order to get it to work on the beaglebone. So I had to spend a weekend hacking the RF24 library to come up with a very thin layer below the library to support all its features on embedded linux boards. I used a beaglebone for testing.

This is a Beaglebone port of the popular RF24(nrf24l01) library posted on https://github.com/maniacbug/RF24/.
If you find the library is out of sync with the Arduino library please drop an email to purinda@gmail.com

Contains portions of the GPIO library posted here,
https://github.com/mrshu/GPIOlib

Complete wiki can be found here
http://maniacbug.github.com/RF24Network/index.html

Features

• Refer to RF24 documentation.

Requirements

• You need a beaglebone with SPI enabled. Look here for a tutorial http://www.yellowfeather.co.uk/2012/03/userland-spi-on-the-beaglebone-with-ubuntu/

How to connect the pins

• I used one of these boards to test the library. http://iteadstudio.com/store/images/produce/Wireless/RF2401/RF24013.jpg
• Connect PIN 1 (GND) of NRF24L01 board to Expansion header P9 PIN 1(GND) of Beagleboard
• Connect PIN 2 (VCC) of NRF24L01 board to Expansion header P9 PIN 3(3v3) of Beagleboard
• Connect PIN 3 (CE) of NRF24L01 board to Expansion header P9 PIN 27(GPIO3_19) of Beagleboard
• Connect PIN 4 (CSN) of NRF24L01 board to Expansion header P9 PIN 25(GPIO3_21) of Beagleboard
• Connect PIN 5 (SCK) of NRF24L01 board to Expansion header P9 PIN 31(SPI1_SCLK) of Beagleboard
• Connect PIN 6 (MOSI) of NRF24L01 board to Expansion header P9 PIN 30(SPI1_D1) of Beagleboard
• Connect PIN 7 (MISO) of NRF24L01 board to Expansion header P9 PIN 29(SPI1_D0) of Beagleboard

Notes

• Note that the library uses a GPIO pin in BeagleBone as CS pin, which is an workaround/issue exist in the code. Planning to fix it whenever I have time.
• Project is written using NetBeans and I have commited some files used by netbeans IDE.
• main.c contains a program which prints out the information of the connected NRF24L01 device and ping demo.
• you may need to upload the Arduino sketch in ‘pingpair_dyn_arduino_pongback’ directory to a Arduino board in order for both Beaglebone and Arduino to run interactively.

Download the source here

https://bitbucket.org/purinda/rf24bb/src

Mounting the BeagleBone on the rover.

It was no big deal.

4 screws to fix the BeagleBone onto the plastic board, some tape for a USB hub and some ideas to hide those way too long USB cables somewhere.

The camera is just for prank, we will have to think of a place to put it, and also a way to hide it’s cable.

What’s missing is of course a lot more compact way to place the electronics and sensors, sensors, sensors.

We were also giving some effort towards using only the BeagleBone so we can let go of the Arduino but for now (and for safety issues) we’ll keep this configuration.

And a fun video for the end. I’m also putting the video of the original design to get some comparison.

This renders the basic Scarabeus project finished.

More work of course is still required but the days of hard work are over. We have finished the rover platform.

Attaching sensors, creating control interfaces are the work of the (not distant) future.

Ahh I forgot to print the logo! Next time…

Angstrom-Cloud9-IDE-GNOME-eglibc-ipk-v2012.05-beaglebone-2012.06.18.img.xz

The difference between this and the previous tutorial is that in the new version of Angström they introduced a light-weight network manager daemon called connman. On one hand this makes things easier but on the other hand it renders all the old tutorials unusable.

To see how to get your hardware running with the BeagleBone read this tutorial:
http://wp.me/p1ILL7-9l

You can check which version are you running:

connmand -v
The output in our case:
0.79

Unfortunately connman seems to be in a less user-friendly shape as the usual linux utilities. By this I mean that there is no direct command line interface to configure but they did set up a test library which contains a few python scripts which you can use to configure things if needed.

root@beaglebone:~# opkg install connman-test

After this you should have the scripts at /usr/lib/connman/test.
Check /var/lib/connman/settings and change WiFi from false to true if necessary.

Create the file which will serve as the default connection config file. You can use your favourite command line text editor, which is vim

root@beaglebone:~# vim /var/lib/connman/wifi.config

Now add these lines and modify them to fit the network you would like to connect to.

[service_home]
Type = wifi
Name = WIFI_NAME_HERE
Security = wpa
Passphrase = WIFI_PASS_HERE

Important! The wifi.config file must have an empty new line at the end of the above text. Here you can read about it.

Now you should have it running after a reset. Instead of the Windows-style all-reset we can reset only the network interface:

root@beaglebone:~# systemctl restart connman.service

You should have it after a few seconds.

Notes about connman:

• it cannot handle multiple connections at the same time (if some version can, please prove it to me with a tutorial)
• you can try to use the old tutorials (containing ifup, ifconfig, iwlist, iwconfig, dhclient), but connman will be likely overriding them

References

http://connman.net/documentation

https://wiki.archlinux.org/index.php/Connman

http://www.gigamegablog.com/2012/02/06/beaglebone-linux-101-assigning-a-static-ip-address-with-connman/

http://learn.adafruit.com/beaglebone/wifi

Plug your BeagleBone, connect to it and also plug the wifi stick.

Let’s see what do you have:

root@beaglebone:~# lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 002: ID 0ace:1211 ZyDAS 802.11bg
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Those 2 hexa numbers are already enough information to determine which driver to use with the stick.

They are called vendor and product id.

Go to http://linuxwireless.org/en/users/Devices/USB and look up your device.

Now go to http://www.angstrom-distribution.org/repo/ and look up the corresponding kernel module package and firmware package.

Examples:

For a ZyDAS 1211 device one should use zd1211-rw kernel module and the zd1211-firmware package.

• root@beaglebone:~# opkg install zd1211-firmware

OR if it says “unknown package”, we can do a bit of workaround.

You should download it from here and put the folder named zd1211 in your /lib/firmware/zd1211. 

To do so you can call something like this after decompressing the downloaded archive:

• root@beaglebone:~# mkdir /lib/firmware/zd1211
• me@laptop:~/unzip/zd1211-firmware$ scp * root@192.168.0.111:../../lib/firmware/zd1211

If you don’t have the firmware available, you should acquire it manually and copy the binary file (or headers) to /lib/firmware/DRIVER_NAME.

If you have an Edimax EW7318USG, you should use the rt73usb kernel module along with the rt73-firmware package (or if it’s not available, go for the below description).

If you have a D-Link 122G which looks like this with lsusb:

Bus 001 Device 002: ID 07d1:3c0f D-Link System

You can check on http://linuxwireless.org/en/users/Devices/USB the vendor and product id. At the time of writing this article there is no such product ID on this page but it’s worth a try to test it’s brothers’ and sisters’ driver. Click on the rt2800usb link next to any of them and check the “firmware” section. This will redirect you to the linux firmware git repo, where you can search for the firmware you need.

For this particular device I downloaded rt2870.bin.

Copy it to /lib/firmware/ and you’re done.

Troubheshooting:

Run dmesg | tail after trying to run a device. You can get useful information here.

To check if you have the necessary kernel modules loaded automatically, run lsmod.

Angstrom-Cloud9-IDE-eglibc-ipk-v2012.01-core-beaglebone-2012.01.11.img.gz

For later versions the classic Linux utilities are controlled by connman so this tutorial will fail to work.

So we managed to set up the cheap wifi stick. I have no idea about it’s name,  the chipset is ZyDas1211.

If you are unsure what chipset your wifi stick has, open it up and check the chip.

Read this post for more on this topic.

Let’s install the necessary packages.

root@beaglebone:~# opkg install wireless-tools
root@beaglebone:~# opkg install dhcp-client
root@beaglebone:~# opkg install kernel-module-zd1211rw 
root@beaglebone:~# opkg install kernel-module-mac80211

So far so good but you are still missing the firmware files. There is a package for them in Angström(for some versions), which can be installed like this:

• root@beaglebone:~# opkg install zd1211-firmware

OR if it says “unknown package”, we can do a bit of workaround.

You should download it from here and put the folder named zd1211 in your /lib/firmware/zd1211. 

To do so you can call something like this after decompressing the downloaded archive:

• root@beaglebone:~# mkdir /lib/firmware/zd1211
• me@laptop:~/unzip/zd1211-firmware$ scp * root@192.168.0.111:../../lib/firmware/zd1211

Now that you have the firmware you can try activating the device:

root@beaglebone:~# ifconfig wlan0 up

To scan the available networks:

root@beaglebone:~# iwlist wlan0 scan

And to connect:

root@beaglebone:~# iwconfig wlan0 essid NETWORK_ID key WIRELESS_KEY

root@beaglebone:~# dhclient wlan0

You can be happy now, you have wifi on your BeagleBone!

For guys wandering around the internet trying to hack their own wifi stick onto the BeagleBone:

Considering you have the kernel module you can tell that you don’t have the firmware files by trying to launch the device like this:

root@beaglebone:~# ifconfig wlan0 up
ifconfig: SIOCGIFFLAGS: No such device

And to make sure that it has to do something with the firmware:

root@beaglebone:~# dmesg | tail
[24708.387603] usb 1-1: Could not load firmware file zd1211/zd1211_ub. Error number -2
[24708.395721] zd1211rw 1-1:1.0: couldn't load firmware. Error number -2

And of course, check the reference links I used to get the wifi up’n'running to get more ideas.

References:

http://roblg.com/blog/2012/02/Belkin-F5D7050-Beaglebone/

http://www.backtrack-linux.org/forums/showthread.php?t=40582

http://www.cyberciti.biz/faq/add-remove-list-linux-kernel-modules/

http://www.cyberciti.biz/faq/inux-kernel-where-to-find-modules/

http://www.ghacks.net/2009/04/14/connect-to-a-wireless-network-via-command-line/

BeagleBone A3 Intro Kit

See Prices from Amazon.com
See Product Details from Amazon.com

BeagleBone A3 Intro Kit Related Articles

Cloud Computing Intro For Beginners
The Internet and email each revolutionized the world in their own ways, and cloud computing looks all set to be the next iteration. There are libraries full of books on this subject, each with a different view of what it means. The simple definition is that the internet is used to provide on-demand access to resources, data and applications…. Read More >>

Intro to SQL Database Design
This article discusses the basic of creating a database. The focus on this article is to be a primer to creating a database with SQL…. Read More >>

Intro to Network Port Scanning and Advanced Techniques: How Snort’s Stealth TCP Port Scanning Works
SecurityWeek Network reported “The simple truth is that the only way to be sure that we actually analyze all network malware-related traffic is to perform a full inspection of all traffic on all ports.” One of the primary tools used by malicious attackers to assess your network weaknesses is the port scan. By running a port scan an attacker can find out what “doors” into your network are open. Once they know that information they can begin to research what sorts of vulnerabilities or exploits that might open up to a network…. Read More >>

Tags: BeagleBone A3 Intro Kit

BeagleBone A3 Intro Kit Related Products

BeagleBone A3 Intro Kit See Prices from Amazon.com See Product Details from Amazon.com

SHOW MORE RELATED PRODUCTS FROM AMAZON.COM >>

This site (computersaccessoriesfopyaq.wordpress.com) is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to Amazon.com.

Now I just need to wait for the components to start trying and build the ArduSwimmer BB cape for OpenROV.

• The BeagleBone card hosts a webserver running a Node.js application
• The browser interacts with node.js app to watch the video feed and to control the ROV
• The Node.js app talks to an Arduino to drive motors and in the future reading sensor’s values.

But a standard Arduino is too big to fit, doesn’t have the connectors for the BeagleBone, so what they built is a BeagleBone cape, with on top an ATMega 328, some power circuitry both for the ATMega and the BeagleBone, the filtered and protect connection to the BeagleBone’s pins and finally the output pins for the motors and servos and AUX output (Leds)

The schematic is a bit difficult to read (maybe just for me because I don’t have a lot of knowledge in electronics) and even more difficult is the board layout. But with a bit of time I got to understand everything and made a list of the components needed to build the cape.

Over the weekend I’ll try getting assembling the components on a solderless breadboard before trying my luck at building it on a protoboard.

Instead of the cool 4×4 truck top I put this plastic panel for now:

On top I fixed every pcb with screws:

1. On the left is my Arduino under a simple shield we made and has a connector for the steering servo and the motor driver.
2. In the middle there is a voltage regulator which is set to create stable 5V from 12V.
3. And the last piece on the plastic panel is the motor driver.
4. In the belly of the robot is a 12V 4000mAh LiPo accumulator.

As a final touch I also put the original bumper back to the front to give it a cool look.

The only thing missing is to put the BeagleBone on top as well. It will be done after we got the wifi working.