Users FAQ

Connections

How can I talk to the E100?

There are three methods to interact with to the E100.

  • Console port through a serial interface
  • Network port using SSH,
  • Graphically with an attached display, keyboard, and mouse.

The console port is the simplest method and required for manipulation of pre-kernel boot settings, while the network interface is faster and required for transferring files to and from the device.

For graphical use, please see the General and Graphics sections of this page.

Can I use the E100 as a USB peripheral like the USRP1?

While it is in theory possible to use the E100 as a peripheral USB Gadget device, the capability is not available at this time. Currently, there are no immediate plans to implement functionality on the E100 to act as a peripheral device.

What kind of USB devices can I connect to the my E1x0 series?

If you plug devices directly to the E1x0 they should be high-speed USB 2.0 if you would like to connect other USB devices then you should use a powered USB 2.0 high speed. If you're using a USB device which would need to get powered over USB (e.g. thumbdrive) you should be using a powered USB 2.0 hub or the device won't function properly.

How do I connect through the console port?

Any program that provides a standard serial terminal can be used to talk to the E100. Common options are Minicom and GNU Screen. Both options are commonly available in typical Linux distributions and package management repositories.

The E100 serial parameters are:
  • Baud Rate: 115200
  • Data: 8-bit
  • Parity: None
  • Stop: 1-bit
  • Flow Control: None

Using a typical USB cable with Standard-A to Mini-B connectors, plug the large end of the cable into the PC and the small end of the cable into the "CONSOLE" port on the E100. Assuming you are on a Linux workstation, the kernel will assign the USB device a file address. The address can be found by running dmesg.

$ dmesg

If you just plugged in your E100, at the bottom of the output you should find something like:

usb 4-2: Detected FT232RL
usb 4-2: Number of endpoints 2
usb 4-2: Endpoint 1 MaxPacketSize 64
usb 4-2: Endpoint 2 MaxPacketSize 64
usb 4-2: Setting MaxPacketSize 64
usb 4-2: FTDI USB Serial Device converter now attached to ttyUSB0

The important part to pay attention to the last line that says "... now attached to ttyUSB0". 'ttyUSB0' is now the device address in your filesystem. Assuming the device is at ttyUSB0, use the following command to connect to your device using screen program.

$ sudo screen /dev/ttyUSB0 115200,cs8,-ixon,-ixoff

When you power on your E100, you should immediately see the console output in your screen. Once the device has finished booted, you should see a login prompt:

.---O---.                                           
|       |                  .-.           o o        
|   |   |-----.-----.-----.| |   .----..-----.-----.
|       |     | __  |  ---'| '--.|  .-'|     |     |
|   |   |  |  |     |---  ||  --'|  |  |  '  | | | |
'---'---'--'--'--.  |-----''----''--'  '-----'-'-'-'
                -'  |
                '---'

The Angstrom Distribution usrp-e1xx ttyO2

Angstrom v20110529 usrp-e1xx ttyO2

usrp-e1xx login: 

How do I connect through the network port?

The E100 runs the SSH daemon by default, and simply using SSH with the device IP address is the preferred mode of communication if you aren't doing pre-kernel-load (boot-time) hacking. For this, the serial console is required.

The E100 uses DHCP. Once the device powers up - give it a minute to finish booting - then check the connected router or DHCP server's IP address records - the device and assigned IP address should be added. Once you have the IP address, SSH into it with the information in the section below this one about login information.

# ssh root@192.168.10.2

Alternatively, the IP address can be obtained by connecting through the serial console and running ifconfig.

# ifconfig

eth0      Link encap:Ethernet  HWaddr A0:36:FA:85:30:CC  
          inet addr:192.168.10.2  Bcast:192.168.10.255  Mask:255.255.255.0
          inet6 addr: fe80::a236:faff:fe85:30cc/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:422 errors:0 dropped:0 overruns:0 frame:0
          TX packets:298 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:47489 (46.3 KiB)  TX bytes:41571 (40.5 KiB)
          Interrupt:80 

What is the login information of the E100?

The root login for your E100 will be one of the following (dependent on model / revision):

  • Username: root
  • Password: usrpe

and

  • Username: root
  • Password: empty

General

What accessories can I attach to the E100?

For many users and applications, the E100 is a fully functional device using only a serial cable, network cable, or operating in standalone mode with no connectivity cables at all. For other use cases, accessories can be attached to the front panel of the E100.

In order to connect peripherals (e.g., a keyboard and mouse) to the E1XX, you will need a powered USB hub. Connect the upstream host port of the hub to the "USB HOST" port using a Mini-A connector. Connect the peripherals to the downstream ports on the hub.

Please note that the E100 cannot be used as peripheral device like the USRP1. Do not connect the "USB HOST" port to a downstream port on a host computer as damage to the device may result.

Here is a list of parts you need in addition to your E1XX (and the power supply, obviously) to have a 'fully operating' setup (i.e., be able to use all of its features):
  • RF Bulkhead Cables (included with E1XX)
  • USB-ADP Adapter Cable (included with E1XX)
  • Daughterboard (Available from Ettus Order Page)
  • Antenna (Available from Ettus Order Page)
  • Ethernet CAT-5e Cable (Available from Ettus Order Page)
  • USB to Mini-B cord (needed for the USB serial console)
  • USB Hub with External Power Source & Mini-A connector
  • USB Keyboard
  • USB Mouse
  • HDMI/DVI-D cable
  • Externally-Powered Speakers
  • Microphone

See the pictures at this link for examples of how to setup your E100: E100 Examples

How do I create / re-create E1xx SD Card Images?

We provide two methods with which you can re-create our master images for E1xx SD Cards:
  1. A 'build directory' with a 'make' script. These files are contained in a tarball: e1xx-xxx-make.tar.bz2
  2. An exact image of our master SD Card. This image is distributed as a compressed image: e1xx-xxx.bin.bz2

As a general rule, the first option is the best choice. The second option requires that you have an SD Card that is the exact same size as the SD Card with which we made the master image. This can be difficult, because even SD Cards that are sold as the same size, made by the same company, can actually be different sizes - sometimes by hundreds of bytes. This obviously affects a 'byte-for-byte' copy of cards, as there could be too little space on the card you are copying to.

Option 1 (Preferred): Using the Build Directory
First, head to the Ettus E1xx Files Directory , and select the directory for the version/revision of image you want to create. Download the e1xx-xxx-make.tar.bz2 file for that version.

Now, de-compress and untar this directory:

$ tar jxvf e1xx-xxx-make.tar.bz2

You should now have a directory 'e1xx-xxx' with all of the files you need to create a copy of our master image. Insert the target SD Card into your favorite device for mounting micro SD cards in your PC (we assume a Linux PC here).

If the partitions automount, umount them (do not "safely remove the hardware"). You can do this by using the 'umount' command for each partition that was mounted.

$ sudo umount /path/to/mount/point/partition

Now, you will want to figure out what the device node is for the SD Card on your PC. You can do this with 'fdisk':

$ sudo fdisk -l

You should see the SD Card near the bottom (probably), and the partitons will have a titles like /dev/sdb1 and /dev/sdb2. From now on, these instructions will presume that the device node is '/dev/sdb'.

Now, we will use the 'MakeEttusSDCard.sh' script to create the card. Note that this script will work with any size SD Card, takes care of partitioning the card for you, creating the boot partition with the proper files, and then populating the root filesystem. Notice that for this command, we are not passing in partitions for the SD Card, but the entire device node itself. Run:

$ sudo ./MakeEttusSDCard.sh /dev/sdb

NOTE: In some Linux distributions the 'MakeEttusSDCard.sh' script will generate an SD image that won't boot, in this case use the 'MakeEttusSDCard.legacy.sh' script instead.

This process will take a significant amount of time, and will generate a lot of output as it populates the root filesystem. Once the process is finished, you should see a message that reports success!

Congratulations, you now have an exact replica of our master image!

Option 2: Burn Our Master Image

First, head to the Ettus E1xx Files Directory , and select the directory for the version/revision of image you want to create. Download the e1xx-xxx.bin.bz2 file for the version you wish to create.

Now, you'll need to de-compress the image:

$ bunzip2 e1xx-xxx.bin.bz2

Now, follow the instructions in the section "How do I burn an image to a microSD Card?" of this FAQ for burning this image (the .bin file) to an SD Card.

How do I burn an image of a microSD Card?

The easiest way to make a backup of the image is to create a 'byte-for-byte' copy of the card. This process will literally read every byte off of the card, and store it into an exact image of the card itself. Thus, the image will be the exact size of the card (in bytes).

Remove the micro SD card from the E100 and insert it into your favorite device for mounting micro SD cards in your PC (we assume a Linux PC here).

If the partitions automount, umount them (do not "safely remove the hardware").

$ sudo umount /path/to/mount/point/boot-xxx
$ sudo umount /path/to/mount/point/rootfs-e1xx-xxx

Now, you will want to figure out what the device node is for the SD Card on your PC. You can do this with 'fdisk':

$ sudo fdisk -l

You should see the SD Card near the bottom (probably), and the partitons will have a titles like /dev/sdb1 and /dev/sdb2 (for the boot and root partitions, respectively). From now on, these instructions will presume that the device node is '/dev/sdb'.

Now, you need to use the 'dd' command to make a copy of that device node. Notice that we are not passing in partitions, but the entire device node itself. Run:

$ sudo dd bs=1024 if=/dev/sdb of=sd-backup.bin

You now have an exact replica of the card! You can burn this image to a SD Card by following the directions in the next section.

How do I burn an image to a microSD Card?

Before continuing, please first read the above section about how images are created. It contains important notes about using 'fdisk' to discover device nodes!

You can restore an image by burning it to an SD Card using the 'dd' command. PLEASE BE CAREFUL - if you tell 'dd' to write to the wrong device node, you could very well overwrite your PC's harddrive! Double-check your device node labels, and then 'dd' the image onto the SD Card:

$ sudo dd bs=1024 if=sd-backup.bin of=/dev/sdb

Please note that the 'dd' command takes a significant amount of time, and will generally eat through a large amount of memory. Do not be surprised if your computer slows down for a long period while this process completes.

How do I set the timezone from the console?

The timezone is set by creating a soft link from a file in /usr/share/zoneinfo to /etc/localtime. There are a set of tzdata opkg's covering different areas and a tzdata file with global coverage. If there is no /usr/share/zoneinfo directory, you need to install a tzdata package.

# opkg install tzdata
# ln -sf /usr/share/zoneinfo/America/Los_Angeles /etc/localtime

You need to find the file in zoneinfo that works for your location. Also, for the change to take effect, you need to log out and back in.

If your E100 is connected to the Internet, you can install ntpdate to set the time.

# opkg install ntpdate
# /usr/bin/ntpdate -b -s -u pool.ntp.org

Firmware and Drivers

How do I install the current Linux kernel and drivers?

The E100 ships with a bootable SD card, however, due to product lead times it is highly recommended that users update the installed Linux kernel, boot files, and kernel modules to a current version. Optionally, the entire root file system, which includes updated kernel modules, can also be updated. Please see the following pages for further information and instructions.

How do I install UHD from source?

Follow the regular build instructions with the following notes:

Remove existing uhd and gnuradio:

# opkg remove --force-depends uhd uhd-dev uhd-examples uhd-tests

Add a user library search path:

# echo "/usr/local/lib" >> /etc/ld.so.conf

Build & Install UHD -- FOR UHD-3.3.1 AND GREATER --:

$ git clone git://ettus.sourcerepo.com/ettus/uhd.git
$ cd uhd/host/
$ mkdir build
$ cd build
$ cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchains/arm_cortex_a8_native.cmake -DENABLE_E100=ON -DENABLE_USRP_E_UTILS=TRUE ../
$ make
$ make test
$ su
# make install
# ldconfig

How do I update the FPGA firmware?

The E100 firmware is loaded from the root file system at runtime. By default UHD will search in the location <install-path>/share/uhd/images. Typically <install-path> will be /usr/local if installing from source. For the UHD installation included with the root file system image (and packager based installations in general), <install-path> will be simply /usr.

The most recent and previous firmware files can be downloaded from the UHD page

Then, follow these steps:

$ cd <install-path>/share/uhd/images
$ su
# mv usrp_e100_fpga.bin usrp_e100_fpga.bin.bak
# wget <paste link>
# tar zxvf <downloaded tarball>
# mv <tarball directory>/share/uhd/images/* .
# exit

How can I test my UHD build and my E1XX?

Assuming you followed the build instructions given above, all built binaries will exist within the uhd/host/build folder. The UHD code contains some example files that you can use to test your E1XX.

$ cd uhd/host/build/examples
$ su
# ./benchmark_rx_rate

You should then see some output detailing the detection of your E1XX and the attached daughterboard, followed by receive rate tests, which look something like this:

Testing receive rate 0.500000 Msps (10.000000 second run)

    Received packets: 9882
    Received samples: 5000292
    Lost samples: 0
    Lost packets: 0 (approximate)
    Sustained receive rate: 0.500000 Msps   

 Testing receive rate 1.000000 Msps (10.000000 second run)

    Received packets: 19763                  
    Received samples: 10000078               
    Lost samples: 0                          
    Lost packets: 0 (approximate)            
    Sustained receive rate: 1.000000 Msps    

(continued)

Eventually, it will test sample rates that are too high, and you will see buffer overruns.

Applications

How do I install GNU Radio from source?

First, remove any existing installation by OpenEmbedded.

# opkg remove --force-depends gnuradio gnuradio-dev gnuradio-examples task-gnuradio

Note that building GNU Radio can take a significant amount of time!!

# git clone http://gnuradio.org/git/gnuradio.git gnuradio.git
# cd gnuradio.git
# mkdir build
# cd build
# cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchains/arm_cortex_a8_native.cmake -DQT_QTCORE_INCLUDE_DIR=/usr/include/qt4/QtCore -DQT_QTGUI_INCLUDE_DIR=/usr/include/qt4/QtGui -DQT_QMAKE_EXECUTABLE=/usr/bin/qmake  -DENABLE_GR_QTGUI=ON  -DQT_LIBRARY_DIR=/usr/lib -DQT_INCLUDE_DIR=/usr/include/qt4/ -DQT_MOC_EXECUTABLE=/usr/bin/moc -DQT_UIC_EXECUTABLE=/usr/bin/uic -DQT_RCC_EXECUTABLE=/usr/bin/rcc -DCMAKE_BUILD_TYPE=release  ../
# make
# make install
# ldconfig

How do install and operate OpenBTS?

Please see the E100 specific OpenBTS wiki

How do I build GNU Radio and GRC with Qt support, from scratch?

Note that this only applies if you are not using one of the Ettus distributed images (e.g., e1xx-001)!! You only need to go through these steps if you are starting with a fresh / clean install of an operating system, and need to build GNU Radio from scratch! The e1xx-xxx images that Ettus Research distributes has these steps already done for you!

You will need to manually build sip, PyQt, and PyQwt:

Download the sip source code: http://www.riverbankcomputing.co.uk/software/sip/download

Build it with these commands (note that this is a short build):

# python configure.py CXXFLAGS+="-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp" CFLAGS+="-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp" 
# make
# make install

Fiddle with qt utility names.

# ln -s /usr/bin/moc /usr/bin/moc4
# ln -s /usr/bin/uic /usr/bin/uic4

Download the PyQt4 source code, available here: http://www.riverbankcomputing.co.uk/software/pyqt/download

Add these lines to /usr/share/qt4/environment-setup.

export OE_QMAKE_CFLAGS="-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp -O3" 
export OE_QMAKE_CXXFLAGS="-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp -O3" 

Now, build PyQt4 (note that this takes a while):

# . /usr/share/qt4/environment-setup
# python configure.py -q /usr/bin/qmake-qt4
# make
# make install

Grab the PyQwt source from here: http://pyqwt.sourceforge.net/download.html

Edit PyQwt configure.py as follows:.

root@usrp-e1xx:~/PyQwt-5.2.0/configure# diff -u configure.py.orig configure.py
--- configure.py.orig   2011-10-22 12:47:03.000000000 +0100
+++ configure.py        2011-10-22 12:54:36.000000000 +0100
@@ -184,7 +184,7 @@
     f.close()

     qmake = os.path.join(configuration.qt_dir, 'bin', 'qmake')
-    os.system('%s -spec %s -o %s %s' % (
+    os.system('%s  -spec /usr/share/qt4/mkspecs/%s -o %s %s' % (
         qmake, configuration.platform, make_file, pro_file))

     # Try and work out the name of make.

Now, build PyQwt (this process takes longer than sip, but not as long as PyQt4):

# ln -s /usr/bin/qmake-qt4 /usr/bin/qmake
# cd PyQwt.../configure
# python configure.py --extra-cxxflags="-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp" --extra-cflags="-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp" 
# make
# make install

Now, you will need to build GNU Radio. This process takes a significant amount of time!

# git clone http://gnuradio.org/git/gnuradio.git gnuradio.git
# cd gnuradio.git
# mkdir build
# cd build
# cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchains/arm_cortex_a8_native.cmake -DQT_QTCORE_INCLUDE_DIR=/usr/include/qt4/QtCore -DQT_QTGUI_INCLUDE_DIR=/usr/include/qt4/QtGui -DQT_QMAKE_EXECUTABLE=/usr/bin/qmake  -DENABLE_GR_QTGUI=ON  -DQT_LIBRARY_DIR=/usr/lib -DQT_INCLUDE_DIR=/usr/include/qt4/ -DQT_MOC_EXECUTABLE=/usr/bin/moc -DQT_UIC_EXECUTABLE=/usr/bin/uic -DQT_RCC_EXECUTABLE=/usr/bin/rcc -DCMAKE_BUILD_TYPE=release  ../
# make
# make install
# ldconfig

Graphics

How do I change the screen resolution?

You can temporarily change the screen resolution by changing the dvimode variable in u-boot. For example

# setenv dvimode 1440x900MR-16@60
# boot

This sets the display resolution to 1440x900. Don't worry about the MR-16@60 bit for now, this should work for most reasonable display resolutions. Once you find a setting that works well with your monitor, you will need to create a boo.scr file to make the change stick across reboots.

Make a file boot.cmd with:

setenv dvimode 1440x900MR-16@60

if run loaduimage; then run mmcboot; fi

in it. Then run:

$ mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n "boot" -d boot.cmd boot.scr

Copy this file onto the FAT partition of the micro SD card and reboot.

mkimage is part of u-boot. I use a copy built by OpenEmbedded and found under tmp/sysroot. This page has more info on u-boot scripts http://www.gumstix.net/wiki/index.php?title=U-Boot

If there are some common resolutions that people need, I'll post some files here so you do not need to create the boot.scr file yourself.