Senior Design Project Checklist

Project name: Enhancing Software Defined Radios for Underwater Acoustic Modem

Sponsor: MITRE

Team members (programs):

Hunter Malboeuf (EE) - Handled the majority of the reports, presentations, website

Davis Meissner (EE) - Made required circuit, helped write MATLAB and C++ code

Gregory Palmer (CMPE) - Wrote most of the MATLAB code & Translated MATLAB code to C++

Faculty advisor(s): Peter Willett

Skills, Constraints, and Standards: (Please check (√) all those that apply to your project.)

Skills: (√)

Analog circuit design and troubleshooting

Digital circuit design and troubleshooting √

Software development/programming √

Embedded Systems/Microcontrollers √

Web design √

RF/wireless hardware √

Control systems

Communication systems √

Power systems

Signal processing √

Machine shop/mechanical design

Other (please specify):

Constraints:

Economic (budget)

Health/safety

Manufacturability

Environmental (e.g., toxic materials, fossil fuels)

Social/legal (e.g., privacy)

Standards:

List standards/electric codes that you used (e.g., IEEE 802.11, Bluetooth, RS-232, VHDL, etc. If applicable, list the name or # here

ECE 4902 Spring 2019

Team 1904: Final Report

Enhancing Software Defined Radios for Underwater

Acoustic Modem

Hunter Malboeuf (EE)

Davis Meissner (EE)

Gregory Palmer (CMPE)

Faculty Advisor: Peter Willett

Sponsoring Company:

The MITRE Corporation

202 Burlington Rd, Bedford, MA 01730

Summary

The underwater acoustic communication channel is extremely challenging due to a low

speed of sound, wide spreading in both Doppler and delay, and extreme geographical variability.

Additionally, acoustic communication technology has previously lacked a capability for rapid

prototyping and performance evaluation. Given these challenges, development and adoption of

acoustic communication technology has been slow [1]. Software-defined radios (SDR) allow for

swift, robust development of radio frequency communication systems that can serve as a possible

answer to the problems posed by underwater communications. They offer the advantages of

operating at relatively low power and being inexpensive to implement in hardware. The goal of

this project was to develop an underwater acoustic communication system utilizing two

Software-Defined Radios, focusing on waveform development. Our initial goal was to set up a

one-way communication channel with one SDR functioning as the transmitter and the other

functioning as the receiver. System performance was evaluated in MATLAB and over a coaxial

connection between radios before being tested on an underwater channel emulator. Stretch goals

included implementing a two-way SDR real-time communication system, as well as adding a

convolutional coding error correction scheme and equalization. Of these stretch goals, an

equalizer was implemented in our design solution to account for multipath effects in the channel.

Signal modulation was focused on the development of a differential phase shift keying (DPSK)

waveform with the goal of sending and receiving small ASCII text messages (up to 36

characters), which was achieved in our team’s design solution.

Background

The need for reliable underwater acoustic communication systems begins with the vast

expanse of the ocean itself. Covering 70% of the planet, with just 2-3% of the area explored, the

ocean remains a frontier for exploration and expansion [2]. Communication systems have the

application of the many underwater machines used today. An example of these would include

underwater instrumentation and sensor networks, manned vehicles like research and military

submarines, and both remote and autonomous unmanned underwater vehicles.

There are a variety of communication methods that have been proposed for underwater

communications. Normal radio frequencies have difficulties being absorbed by seawater. Optical

communication systems face issues with high attenuation and dependence on the clarity of the

water. Extremely low-frequency RF communications would require antennas that are

impractically long, as well as operating within an extremely narrowband (about 50 Hz) [2].

Physical cables are operationally sound, but are expensive to deploy and are impractical for

mobile environments. This leads to the best current solution to be acoustic communication

systems. They operate at relatively low power at 10-100 W for the transmitter and 100 mW at the

receiver, while also being inexpensive to implement in hardware [2].

There are many challenges of underwater acoustic communication. First, the underwater

channel is varied in time and frequency, producing an uneven channel impulse response as time

progresses. Multipath effects pose an issue as the transmitted signal reflects off of the sea

surface, sea bottom, and any other objects present in the water, causing the signal to arrive at the

receiver at different points in time. Doppler spreading due to transmitter and receiver motion in

the water can cause issues with synchronization between both instruments. Attenuation over the

underwater channel is also difficult to compensate for, as it is dependent on water temperature

and depth of operation of the system.

This project continued to build off of the progress of previous Senior Design teams that

worked with MITRE. The 2017 team employed a BPSK modulation scheme for their underwater

communication system solution, with development of the waveform in GNU Radio. The 2018

team developed the basis for the underwater channel that operates on the Ettus X310 SDR, which

was also developed using GNU Radio. Our 2019 team focused on the development of the

waveform to include error correction, interleaving, modulation using differential phase-shift

keying (DPSK), message detection and synchronization, and equalization (stretch goal).

Platform

For the hardware implementation of the communication system and evaluation of its

performance, we required the following components:

- Three Ettus X310 Software Defined Radios

- Three UDOO X86 embedded processors (transmitter, receiver, channel emulator)

- Preamplifier (for the signal entering the receiver)

- Assorted Cables (ethernet, coaxial, HDMI, attenuator)

The Ettus X310 radios and the embedded processors possessed the necessary processing

capability to handle our signal processing requirements. These components were integrated to

form the one-way communication system using C++ on the UDOO X86 processors, each of

which runs the Ubuntu Linux platform. This required us to take our prototype MATLAB code

and convert it over to C++ for the actual hardware implementation. Rather than using an

automatic C++ code generator in MATLAB, we translated the original code over to C++

ourselves. This had the benefit of making our C++ code be more legible, easier to debug, and a

solution that our team and MITRE could more easily make use of. It’s important to note that

MITRE provided the necessary template C++ code that allowed the embedded processors and

SDRs to interface between each other, which allowed us to focus on developing our waveform to

best perform in an underwater channel.

The hardware setup for communication over the coaxial wire is displayed in Figure 2:

Figure 2: Hardware Setup for Transmission over Coaxial Wire

The hardware setup for transmission over the channel emulator is displayed in Figure 3:

Figure 3: Hardware Setup for Transmission over Channel Emulator

Before we tested our integrated communication system on the channel emulator that was

designed by the 2018 UConn Senior Design team, the system was tested over a coaxial wire

between the transmitter and receiver. A 30 dB attenuator was also connected at the receiver. The

waveform data in each stage of the communication block diagram shown in Figure 1 was

subsequently analyzed in MATLAB. This was extremely valuable to our team to understand

what exactly was occurring at each stage of the encoding and decoding process. This method was

also used in debugging stages where the root cause of errors in our C++ code was unknown.

Solution

I. I. Introduction

Our solution to developing an underwater acoustic communication system utilizing two

SDRs is broken up into three phases. These phases are:

1. Simulation: Initial waveform and communication system design simulated in

MATLAB using a tool provided by MITRE. Waveform performance was tested with an

additive white Gaussian noise channel, channel impulse response, and non-time-varying

acoustic channel based on the Stojanovic model. This allowed for an evaluation of our

developed waveform before proceeding with the hardware implementation, as well as an

evaluation of data from hardware solution.

2. Hardware Integration: Integration of our communication system developed in software

with our hardware required conversion of the MATLAB program into a C++ program.

This allowed for interaction between the SDRs (Ettus X310) and host machine embedded

processors (UDOO X86).

3. Analysis of System Performance: Overall analysis of our signal detection,

synchronization, error correction, interleaving, and equalization capabilities. The

obtained data could be used to determine a quantity like the bit error rate and the system’s

overall ability to overcome the effects of the underwater channel.

From a simulation standpoint, a starter acoustic communication system MATLAB model

provided by MITRE was adapted to our needs, with waveform development as the focus of our

solution. The MATLAB model was consistently altered over the course of the project to improve

performance, including prototyping our synchronization and equalization techniques. A block

diagram of the flow of data through the designed communication system is pictured in Figure 1.

A more detailed description of each completed communication element displayed below is

necessary to understand the development of the waveform in MATLAB and application in C++.

Figure 1: Communication Block Diagram [1]

Our system in both the MATLAB and C++ implementations began by reading a defined

message from a text file and converting the ASCII characters to their 8-bit binary representation.

This process is exhibited in Figure 2. The capability to directly write the text message in the C++

code and send this message was added later on. After the conversion of ASCII characters to

binary bits, the error control coding process begins.

Figure 2: ASCII Bits From Text File

II. II. Error Correction

Error correction was implemented in our MATLAB and C++ design solutions for the

acoustic communication system. Our choice of error correction was a Hamming Code (7, 4),

adding three parity bits to every four message bits in our signal. A final redundancy error check

is used to check for a valid transmission after reception, which is a four bit sequence at the end of

the payload of either 0’s or 1’s. If the final error check fails, our C++ solution signals that the

message was corrupted over the channel. The bit sequence after undergoing the Hamming Code

(7,4) error control encoding scheme is displayed in Figure 3.

Figure 3: Data Bits With Added Hamming Bits

III. III. Interleaving

Interleaving was used in each of the design solutions. Our team implemented a matrix

interleaving method that redistributed the message and parity bits before modulation occurred.

This operates by sorting the data bits into a square matrix of n rows by n columns, reading the

data back out in a transposed order. This is done to compensate for any burst errors in the

received signal and allow for the Hamming code error correction method to more efficiently

correct any bits that were altered by the channel. The interleaved data before the modulation

process is shown in displayed in Figure 4. On the receiver end, the de-interleaving process

reorganizes the the square matrix into the original bit order from the transmitter side.

Figure 4: Interleaved Data Bits

IV. IV. Modulation

The signal is modulated using a differential phase-shift keying (DPSK) modulation

scheme. DPSK was chosen over the BPSK scheme that was implemented previously because of

its non-coherent properties, eliminating the need for the receiver to keep track of a reference

waveform. This property makes DPSK better suited for the underwater channel in our

application. Our carrier waveform is set to 14 kHz and with a sampling rate of 480 kHz and a

symbol rate of 4 kHz. This determines the effective symbol rate to be 120 samples per symbol,

which was more than adequate to make our bit decisions on the receiver side of the system.

These sampling and symbol rates were chosen since they are the minimum values allowed by the

Ettus X310 SDRs. Images of the transmitted signal with a detailed image of a change from a 0 to

a 1 is shown in Figures 4 and 5.

Figure 5: Ettus X310 Transmitter Output Waveform

Figure 6: 180° Phase Shift Defining A Transition From 0 To 1

The complete modulated signal is displayed by Figure 7 below. This includes the preamble chirp

signal, following by a data gap, and then the payload data representing the original ASCII text

message.

Figure 7: Transmitted Waveform Including Preamble, Data Gap, and Payload

The demodulation process that occurs in both the MATLAB and C++ code is summarized by the

diagram displayed by Figure 8:

Figure 8: DPSK Demodulation Process [3]

V. V. Synchronization

A synchronization process between the transmitter and receiver was achieved by adding a

preamble signal followed by a data gap, both of which precede our data payload. Our

synchronization signal is a sinusoidal wave that sweeps from 12 kHz to 16 kHz over a 2.5 ms

period and is commonly referred to as a “chirp” type of synchronization message. The data gap

allows our system time to find the chirp message and prepare to receive the payload signal. On

the receiver side our design uses a correlation operation to determine the beginning of the

message signal and allow the decoding process to occur. To account for any phase changes

across the transmission, we perform the correlation with a cosine and sine version of our chirp

signal, by taking these correlation results, squaring them and adding them together, we get a

consistent and reliable correlation value that we can apply a threshold value in order to determine

the position of the chirp signal. Once we accurately know the position of our chirp signal,

waiting the appropriate amount of samples to then grab the payload signal, even in the presence

of noise, becomes trivial. This synchronization process is explained by the C++ code in Figure 9.

Figure 9: Synchronization Process

Figure 10: Correlation Peak During Synchronization Process

VI. VI. Equalization

We were supplied with code from MITRE that emulates an underwater channel path as

displayed in Figure 11. Our equalization design works by adding a package of known training

data to the front of our our payload data. The receiver side knows what this training data is

supposed to look like, and tries to correct for any multipath transmission errors that may have

occurred in the channel. We perform the calculations on our matched filter outputs to minimize

the amount of calculations on the UDOO board.

MATLAB CODE:

N = length(training_data_matched_filter_output);

mu = .05;

d = (training_data*2 - 1);

x = training_data_matched_filter_output;

h = zeros(M,1);

y_eq = zeros(1,N);

e = zeros(1,N);

for n = M+1:N

x_vec = x(n:-1:n-M+1)';

y_eq(n) = h'*x_vec;

e(n) = d(n) - y_eq(n);

h = h+mu*e(n)*x_vec;

end

%% Bit decision

for i = 1:length(u_payload)-1

y = 0;

for k = 0:M-1

if(i-k+1 > 0)

y = y + h(k+1)*u_payload(i-k+1);

end

end

if y > 0

sig_out(i)=1

else

sig_out(i)=0;

end

Figure 11: Underwater Channel Emulation Response

Figure 12: Adaptive Equation Adjusting To Training Data

Results

After we spent the majority of the Fall 2018 semester prototyping our waveform in

MATLAB and learning how to operate our hardware, we transitioned to porting our MATLAB

code to C++ and integrating with our hardware. This started with adding each of our

communication system design elements block by block in the starter C++ code provided by

MITRE. We faced difficulty in this stage integrating the function libraries used in MATLAB

with those used in C++, which forced us to rewrite multiple aspects of our code. After, we were

quickly able to add error correction, interleaving, modulation, and the ability to read from a text

file to C++. At the same time, we were prototyping our synchronization and equalization process

in MATLAB.

After we ported the initial synchronization process to C++, we attempted to run the full

system by transmitting and receiving. This was halted by multiple runtime errors in the C++

code, which required us to take a closer look at the defined parameters within the code and our

configuration file. We then altered our sampling and transmission rates to the rates defined in the

in our final solution. This resolved many of our runtime errors and after debugging smaller

errors, our program could read from a text file, error encode, interleave, and modulate our signal.

After viewing our modulated signal on an oscilloscope, we tuned our gain settings at the

transmitter to create a wave with a higher amplitude that could better handle the effects of the

underwater channel. We then needed to examine our synchronization process, as our receiver

was having trouble properly detecting the message signal. This is where we altered our “chirp”

signal to ramp from 12 kHz to 16 kHz over the 2.5 ms period, where we previously had the

signal ramp from a much lower frequency. This extended the number of symbols contained in

the “chirp”, which was beneficial in providing a larger amount of data for the correlation step to

We also adjusted our buffer settings within the synchronization process to fix an issue where

sections of data were being cut off and left out of the correlation step.

At this point, we tested our synchronization process again and found that the message

would be detected, but out of alignment by a random number bits. After examining our

hardware, we determined that our coaxial cable connecting the transmitter and receiver was

faulty. Even after replacement, our synchronization process was failing to properly catch the

payload. After discussion from MITRE, we determined that the carrier frequency of 14 kHz was

being set more than once within our code. We also discovered that we were performing a

convolution within the synchronization process rather than a correlation operation. After this

minor change and multiple tweaks to debug the system, we successfully transmitted and received

small ASCII text messages over a coaxial wire between the transmitter and receiver. After this

solution, we implemented the same changes to the MATLAB prototype and tested over a non-

time-varying underwater channel emulator, rather than the AWGN channel used previously. We

were consistently able to transmit and receive messages within this prototype. We then began

work tuning the equalizer in the MATLAB prototype. To date, the equalizer is implemented and

functional in MATLAB, where can successfully transmit and receive over the underwater

channel emulator. In our hardware solution, we can successfully transmit and receive over a

coaxial cable with a 30 dB attenuator attached.

The final deliverables to MITRE for this project include the MATLAB and C++

communication system code. Ultimately, we were successful in our goal to implement a one way

SDR communication system in both MATLAB and in C++ with our integrated hardware. Our

focus on waveform development to include elements of error coding control, interleaving, DPSK

modulation, and synchronization lead us to successfully implement each of these elements. We

also made significant progress on our stretch goal of adding equalization at the receiver, which

was successfully implemented in the MATLAB prototype. Work for a future group could include

tasks to more thoroughly test the hardware implementation over a channel emulator, as well as

perform underwater testing with acoustic hydrophones connected as peripherals to the SDRs.

Lastly, they could implement our MATLAB equalization technique in C++.

Information about Personnel and Collaborators

Our team was advised by Dr. Peter Willett of the University of Connecticut. We met with Dr.

Willett on multiple occasions to discuss and explore the technical requirements of this project.

We also met with Dr. Willett for guidance on technical methods that were incorporated into our

design solution. The project was sponsored by The MITRE Corporation. Individuals at MITRE

that provided assistance and guidance were Dr. Tamara Sobers, Dianne Egnor, and Dan

Wilbanks. Our team and Dr. Willett held weekly meetings with the team at MITRE to discuss

weekly deliverables, answer questions, and discuss the plan moving forward each week. We also

had access to a MITRE SharePoint website to exchange information on our current MATLAB

and hardware results, transfer C++ hardware integration code, and receive the channel emulator

code for both MATLAB and C++.

Budget

All necessary equipment was acquired from MITRE on a visit to their Bedford, MA location on

November 19th. MATLAB is free for UConn Engineering students to access and the Ubuntu

platform that ran on the UDOO processors is free to use. Because the hardware has been loaned

for the duration of the project and will be returned after the Demonstration Day on May 3rd,

budget has not been a concern for this project.

[1] MITRE. 2019 Senior Design Project Outline

[2] MITRE. Waveform Development for Underwater Acoustic Communications

[3] DPSK Image from Tutorials Point

https://www.tutorialspoint.com/digital_communication/digital_communication_differential_phas

e_shift_keying.htm