We will use Ubuntu 14.04 for our purposes. Basically, it’s possible to use any Ubuntu system, but we tested everything on 14.04 and guarantee that it will work fine. UHD library built with loadable modules support could be downloaded from Josh Blum’s PPA. Thus, we need to open Terminal and enter:

$ sudo apt-get install python-software-properties
$ sudo add-apt-repository ppa:guruofquality/pothos

Python-software-properties provides the add-apt-repository binary, which is necessary to install a new ppa (Personal Package Archive, is a collection of software not included in Ubuntu by default, https://help.launchpad.net/Packaging/PPA) easily. Pothos repository contains a proper UHD package for UmTRX. Update the cache of the Software Center repository:

$ sudo apt-get update

To install UHD driver from that repository, we should open Ubuntu Software Center. From drop-down menu of All Software button choose Pothos and scroll down until «uhd» package appears. That’s the one we need to install.

It’s also possible follow the standard procedure described in the UHD build guide to build it from the source (http://files.ettus.com/manual/page_build_guide.html).

Once UHD has been installed the UmTRX module must be built and installed over it. We have just installed Ubuntu 14.04 so some necessary software for building UmTRX module is abscent. It’s easy to get, though!

$ sudo apt-get install git
$ sudo apt-get install libboost-all-dev
$ sudo apt-get install build-essential
$ sudo apt-get install cmake

Git is a widely used version control system for software development. Boost is a set of libraries for the C++ programming language that provide support for tasks and structures such as linear algebra, pseudorandom number generation, multithreading image processing, regular expressions, and unit testing. The build-essentials is a reference for all the packages needed to compile a debian package. It generally includes the gcc/g++ compilers an libraries and some other utilities.

We are ready to install UmTRX module right now:

$ git clone https://github.com/fairwaves/UHD-Fairwaves.git
$ cd UHD-Fairwaves/host
$ mkdir build
$ cd build
$ cmake ../
$ make

In this part we cloned Fairwaves repository to the local folder, created a folder for the installation and built the module. To install the driver with a package:

$ cpack
$ sudo dpkg -i umtrx_*.deb

We highly recommend to use Josh Blum’s UHD driver as we based the development of UmTRX driver on it.

It is suitable moment to setup and boot UmTRX board to ensure if the installation went correctly.

The UmTRX Lab Package includes a power supply, GPS antenna and pigtail wires for GSM antennas. The user have to take care of assembly and cooling. A 3-pin mains lead is required.

Cooling is necessary and the heat generated must be dissipated in a stable manner in order to avoid permanent damage of the UmTRX. Cooling using fans is easy to implement but is mostly suited to indoor use. Two fans may be connected via the connectors X17 (FAN1) and X18 (FAN2). FAN1 is constantly powered and FAN2 is automatically switched on/off by U35 (MAX6665ASA45) when the temperature is around 45°C. The maximum DC current of FAN2 must be less than 400mA.

TX and RX antennas should be selected according to the application. Damage may occur if UmTRX is set to transmit without a suitable 50 ohm load connected! We will use antennas from the box.

As we plugged power and cooling, we need to connect our board to computer via ethernet cable directly or via switch. For now, UmTRX does not support 100M Ethernet and it will not be recognized if your computer does not support gigabit Ethernet. Though, if your PC ethernet port supports only 100 Mbit/s, you may use 1GBit/s network switch. By default UmTRX has a static IP address 192.168.10.2/24, so it is recommended to set your computer’s IP address to 192.168.10.3/24.

It’s easy to check, if UmTRX and UHD were installed properly:

$ uhd_find_devices

If the result was like that, we made everything right:

We may also probe the properties of the attached device:

$ uhd_usrp_probe 192.168.10.2

The output of the command shows different properties of our UmTRX, such as driver version and channel settings.

The next step is installation of GNU Radio package into our Ubuntu system. We recommend to use build-gnuradio script as it would allow to install the latest version of the package and not to overwrite our existing UHD driver. Create a folder in your /home to avoid any issues with file permissions.

$ wget http://www.sbrac.org/files/build-gnuradio && chmod a+x ./build-gnuradio && ./build-gnuradio prereqs gitfetch gnuradio_build

We are using additional parameters prereqs, gitfetch and gnuradio_build to check if our prerequisite software is installed (and install it if necessary), copy the installation files to created folder and build GNU Radio only, without UHD driver. The process takes about 2 hours, so please be patient.

To have more options in experiments with SDR, it’s helpful to install Osmocom GNU Radio Blocks (http://sdr.osmocom.org/trac/wiki/GrOsmoSDR). By using the OsmoSDR block we can take advantage of a common software API in our application(s) independent of the underlying radio hardware.

$ git clone git://git.osmocom.org/gr-osmosdr
$ cd gr-osmosdr
$ mkdir build
$ cd build
$ cmake ../
$ make
$ sudo make install
$ sudo ldconfig

So, the script finished it’s work and we are ready to have some fun with GNU Radio!

The post Journey to GSM. Part 2. Installation appeared first on Fairwaves.

We’re happy to announce start of public sales of UmTRX 2.3.1 – the only widely available Software Defined Radio (SDR) designed specifically for telecom applications.
UmTRX 2.3.1 is a key part of our UmSITE base stations and are deployed on all continents and are suitable for both Siberia-cold and Sahara-hot temperatures (see UmSITE temperature tests).

UmTRX 2.3.1 is a compact dual-channel SDR built for embedded systems suitable for industrial, outdoor, harsh and remote environments. It is designed as a base station transceiver and thus has specific features required for this like power amplifier and external RF front-end control ports.

Find more information in the announcement on umtrx.org web-site and UmTRX 2.3.1 product page. More technical details are available in the UmTRX 2.3.1 datasheet.

Contact us for volume pricing.

The post Embedded version of UmTRX is finally available for everyone appeared first on Fairwaves.

Software Defined Radio is a radio system which performs the required signal processing in software instead of using dedicated integrated circuits in hardware. The advantage of that approach is that since software can be easily replaced in the radio system, the same hardware can be used to create many kinds of equipment for many different radio standards. Therefore, one SDR can be used for a variety of applications. SDR is a technology that makes IT and Telecommunications closer to each other.

Basically, our system should consist of two parts: computer with software and SDR transceiver. There are plenty of SDR transceivers: UmTRX, USRP, HackRF, BladeRF, etc. Which one to choose?
As we are going to work with GSM, it would be wise to choose SDR that was created with consideration of GSM specifications. There is such SDR solution on the market. It is named UmTRX and was developed in Fairwaves.

UmTRX is based on the open source hardware (Altium Designer schematic and board layout files are made available under the Creative Commons Attribution-ShareAlike 3.0 Unported license) and can be deployed using open source software (for example, GNU Radio, Osmocom family of open source projects), therefore it benefits from being part of an ever-growing ecosystem of complementary hardware and software for mobile communications. UmTRX was developed to be used as a transceiver for OpenBTS and OsmoBTS GSM base stations considering GSM specifications, but due to its SDR nature it could be used for many other applications as well. It operation based on the Ettus UHD driver. UmTRX has its own GPS clock (26 MHz Voltage Controlled Temperature Compensated Crystal Oscillator) and industrial grade components (such as Lime Microsystems Multi-band Multi-standard Transceiver with Integrated Dual DACs and ADCs LMS6002D). UmTRX has two independent channels, so one can operate on two different frequencies. As it works in different environment conditions all over the world, like hot climate of Africa and high humidity of tropical islands, we can be sure it will work on our table.

As we decided our hardware option, we need to choose our first application. Let’s try to investigate GSM signals using our UmTRX.

We are going to use GNU Radio software to build that project. GNU Radio (https://gnuradio.org) is a free and open-source software development toolkit that provides signal processing blocks to implement software radios. You can use it to write applications to receive data out of dial streams or to push data into digital streams, which is then transmitted using hardware. GNU Radio has filters, channel codes, synchronisation elements, equalizers, demodulators, vocoders, decoders, and many other elements which are typically found in radio systems. More importantly, it includes a method of connecting these blocks and then manages how data is passed from one block to another.

Our hardware part needs to receive radio frequency (RF) analog signals and transform them into the digital form using Analog-to-Digital Converter (ADC). UmTRX system should do that job easily. As for software part, digital signal processing (DSP) is where GNU Radio has a plenty of tricks.

The post Journey to GSM. Part 1. Introduction appeared first on Fairwaves.

Recently, our engineers made a patch for OpenBTS-UMTS that allows to launch UMTS-3G network on UmTRX hardware. In this article you will find all the details. Scroll down to see video how it works!

OpenBTS-UMTS (http://openbts.org/w/index.php?title=OpenBTS-UMTS) is a Linux-based application that uses a software radio to present a UMTS network to any standard 3G UMTS handset or modem. It builds upon the OpenBTS framework, where the Mobile Station (MS) or User Equipment (UE) is treated as an IP endpoint at the edge of the network.

3GPP UMTS, the Universal Mobile Telecommunications System is the third generation (3G) successor to the second generation GSM based cellular technologies such as GPRS and EDGE. UMTS uses a totally different air interface, but the core network elements have been migrating towards the UMTS requirements with the introduction of GPRS and EDGE.

UMTS based upon Wideband Code Division Multiple Access (WCDMA / W-CDMA) to carry the radio transmissions. It employs a 5 MHz channel bandwidth. Using this bandwidth it has the capacity to carry over 100 simultaneous voice calls, or it is able to carry data at speeds up to 2 Mbps in its original format. Code divison multiple access enables multiple handsets or user equipments to have access to the base station. Using a scheme named direct sequence spread spectrum, different UEs have different codes and can simultaneously talk to the base station even though they are using the same frequency.

The UMTS network architecture consists of three main elements: User Equipment, Radio Network Subsystem (RNS) and Core Network. The User Equipment is the name given to what was previous named the Mobile Station. The new name emphasizes it could be anything between a mobile phone used for talking to a data terminal attached to a computer with no voice capability. The RNS also known as the UMTS Radio Access Network is the equivalent of the Base Station Subsystem in GSM. It provides and manages the air interface for the overall network. The Core Network provides all the central processing and management for the system. It is the equivalent of the GSM Network Switching Subsystem.

UMTS radio access network comprises two main components: Radio Network Controller (RNC) undertakes the radio resource management, encryption, connection initialization. Node B is a UMTS base station transceiver. This part of the RNS contains the transceiver to communicate with the UEs within the cell. It participates with the RNC in the resource management.

In UMTS MSC (GSM Mobile Switching Center) functions were divided between two elements: MSC-Server and MGW (Media gateway). MSC-Server is responsible for connection establishment, signalling, authentification and Interworking. All subscriber’s traffic is switched in MGW under control of MSC-Server.

Radio aspects of 3G, including UMTS may be found in 25 series of 3GPP standards (http://www.3gpp.org/DynaReport/25-series.htm).

OpenBTS-UMTS and UmTRX software installation

On the video you may find the demonstration of how 3G-UMTS works on UmTRX.

Please note, that unlike GSM, you can’t have open registration and thus you can’t just use any random SIM card – you need a programmable SIM-card.

As we have an idea about UMTS, it’s time to install the necessary dependencies, which required to run OpenBTS-UMTS software. The installation was tested on Ubuntu 14.04 and assumes that user already has installed UHD and UmTRX module. The details of the UHD and UmTRX installation may be found there: http://umtrx.org/hardware/driver/.

$ sudo apt-get install libreadline6 libreadline6-dev libosip2-dev

The GNU readline library aids in the consistency of user interface across discrete programs that need to provide a command line interface. Libosip2 header files and static libraries are used to assist in development of programs wishing to use SIP.

We also need ASN.1 C compiler that turns the formal ASN.1 specifications into the C code.

$ git clone https://github.com/vlm/asn1c.git
$ cd asn1c
$ git checkout 80b3752c8093251a1ef924097e9894404af2d304
$ ./configure
$ make
$ sudo make install

OpenBTS uses the coredumper shared library to produce meaningful debugging information if OpenBTS crashes:

$ git clone https://github.com/RangeNetworks/libcoredumper.git
$ cd libcoredumper
$ sudo ./build.sh
$sudo dpkg -i libcoredumper1_1.2.1-1_amd64.deb libcoredumper-dev_1.2.1-1_amd64.deb

We are ready to install OpenBTS-UMTS itself.

$ git clone -b fairwaves/umtrx https://github.com/fairwaves/OpenBTS-UMTS
$ cd OpenBTS-UMTS
$ git submodule init
$ git submodule update
$ sudo NodeManager/install_libzmq.sh
$ ./autogen.sh
$ ./configure
$ make
$ sudo make install

To setup OpenBTS-UMTS, we may need to modify the settings such as ARFCN, DNS, Firewall. Navigate to ~/OpenBTS-UMTS/apps folder and open OpenBTS-UMTS.example.sql file with the preferable text editor. You may need to edit following options:

• ‘GGSN.DNS’ set to ‘8.8.8.8’ to enable Google DNS.
• ‘GGSN.Firewall.Enable’ set to ‘0’ to disable Firewall.
• ‘UMTS.Radio.Band’ – set the band you are going to use. Select from 850, 900, 1700, 1800, 1900 or 2100.
• ‘UMTS.Radio.C0’ – set the UARFCN. Range of valid values depend upon the selected operating band. Please, ensure that you are using free operating band.

Now, we need to create folders and working database:

$ sudo mkdir /var/log/OpenBTS-UMTS
$ cd /etc/OpenBTS
$ sudo sqlite3 /etc/OpenBTS/OpenBTS-UMTS.db “.read OpenBTS-UMTS.example.sql”
$ sudo cp TransceiverUHD/transceiver ~/OpenBTS-UMTS/
$ sudo cp TransceiverUHD/transceiver apps

We also need to setup forwarding in iptables to properly forward data between devices, host machine, and the Internet:

$ sudo su
$ iptables -t nat -A POSTROUTING -j MASQUERADE -o eth0
$ echo 1 > /proc/sys/net/ipv4/ip_forward
$ exit

If you have Internet connection through the another interface (for example, Wi-Fi), you need to change eth0 to the applicable one (i.e., wlan0). Please note, that you need to setup forwarding in iptables every time after you computer rebooted.

It’s important to install Subscriber Registry API and SIP Authentication Server to be able to launch OpenBTS-UMTS. Subscriber Registry controls database of subscriber information and in fact works as HLR (Home Location Registry):

$ git clone https://github.com/RangeNetworks/subscriberRegistry.git
$ cd subscriberRegistry
$ git submodule init
$ git submodule update
$ sudo NodeManager/install_libzmq.sh
$ autoreconf -i
$ ./configure
$ make
$ sudo make install
$ sudo mkdir /var/lib/asterisk/
$ sudo mkdir /var/lib/asterisk/sqlite3dir/
$ sudo cp apps/comp128 ~/OpenBTS-UMTS/
$ sudo cp apps/comp128 ~/OpenBTS-UMTS/apps/
$ sudo cp apps/comp128 /OpenBTS

Let’s run OpenBTS-UMTS and Subscriber Registry:

$ cd OpenBTS-UMTS/apps
$ sudo ./OpenBTS-UMTS
$ cd subscriberRegistry/apps
$ sudo ./sipauthserve

To add the subscriber to the registry, you need to know IMSI and K_i value of your programmable SIM card. There are two common ways to get the values. The only way to use SIMs from another provider is to obtain the K_i through a roaming interface to the provider’s HLR/HSS. The second way is to buy test SIM-card and flash it using the programmer and pysim utility (http://cgit.osmocom.org/pysim/). Navigate to ~/subscriberRegistry/NodeManager/ and execute:

$ sudo ./nmcli.py sipauthserve subscribers create “name” imsi msisdn ki

Values imsi, msisdn and ki should be taken from your SIM-card.

Now, connect your phone to the network and test 3G. That’s it!

For those, who are eager to run UMTS on his own table as soon as possible, here is the Contact Form.

The post How to get 3G working on the UmTRX appeared first on Fairwaves.