1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156

liquiddsp
==========
SoftwareDefined Radio Digital Signal Processing Library
liquiddsp is a free and opensource digital signal processing (DSP)
library designed specifically for softwaredefined radios on embedded
platforms. The aim is to provide a lightweight DSP library that does not
rely on a myriad of external dependencies or proprietary and otherwise
cumbersome frameworks. All signal processing elements are designed to be
flexible, scalable, and dynamic, including filters, filter design,
oscillators, modems, synchronizers, and complex mathematical operations.
For more information, please refer to the documentation:
* online HTML version: [http://liquidsdr.org/doc](http://liquidsdr.org/doc)
* precompiled `.pdf` version: [liquid.pdf](http://liquidsdr.org/downloads/liquid.pdf) (4.4 MB).
Installation and Dependencies

liquiddsp only relies on `libc` and `libm` (standard C and math)
libraries to run; however liquid will take advantage of other packages
(such as [FFTW](http://www.fftw.org)) if they are available.
### Getting the source code ###
There are two primary ways of obtaining the source code:
1. Clone the entire [repository](http://github.com/jgaeddert/liquiddsp)
(recommended)
$ git clone git://github.com/jgaeddert/liquiddsp.git
2. or download the [tarball](http://liquidsdr.org/downloads/liquiddsp1.2.0.tar.gz)
(2.6 MB), validate the checksum, and unpack
$ wget http://liquidsdr.org/downloads/liquiddsp1.2.0.tar.gz
$ wget http://liquidsdr.org/downloads/liquiddsp.md5
$ md5sum check liquiddsp.md5
$ tar xf liquiddsp1.2.0.tar.gz
### Installation ###
Once you have obtained a copy of the source code, you can now build the
DSP library (NOTE: if you chose to clone the repository, you will need
to also run the additional `./bootstrap.sh` script before configuring):
$ ./bootstrap.sh # < only if you cloned the Git repo
$ ./configure
$ make
$ sudo make install
If you are installing on Linux for the first time, you will also need
to rebind your dynamic libraries with `sudo ldconfig` to make the
shared object available.
If you decide that you want to remove the installed DSP library, simply
run
$ sudo make uninstall
### Run all test scripts ###
Source code validation is a critical step in any software library,
particulary for verifying the portability of code to different
processors and platforms. Packaged with liquiddsp are a number of
automatic test scripts to validate the correctness of the source code.
The test scripts are located under each module's `tests/` directory and
take the form of a C source file. liquid includes a framework for
compiling, linking, and running the tests, and can be invoked with the
make target `check`, viz.
$ make check
### Examples ###
Nearly all signal processing elements have a corresponding example in
the `examples/` directory. Most example scripts generate an output
`.m` file for plotting with [GNU octave](http://www.gnu.org/software/octave/)
All examples are built as standalone programs and can be compiled with
the make target `examples`:
$ make examples
Sometimes, however, it is useful to build one example individually.
This can be accomplished by directly targeting its binary
(e.g. `make examples/modem_example`). The example then can be run at the
command line, viz. `./examples/modem_example`.
### Benchmarking tool ###
Packaged with liquid are benchmarks to determine the speed each signal
processing element can run on your machine. Initially the tool provides
an estimate of the processor's clock frequency and will then estimate
the number of trials so that each benchmark will take between 50 and
500 ms to run. You can build and run the benchmark program with the
following command:
$ make bench
Available Modules

* _agc_: automatic gain control, received signal strength
* _audio_: source audio encoders/decoders: cvsd, filterbanks
* _buffer_: internal buffering, circular/static, ports (threaded)
* _channel_: additive noise, multipath fading, carrier phase/frequency
offsets, timing phase/rate offsets
* _dotprod_: inner dot products (real, complex), vector sum of squares
* _equalization_: adaptive equalizers: least meansquares, recursive
least squares, semiblind
* _fec_: basic forward error correction codes including several
Hamming codes, single error correction/double error detection,
Golay block code, as well as several checksums and cyclic
redundancy checks, interleaving, soft decoding
* _fft_: fast Fourier transforms (arbitrary length), discrete sin/cos
transforms
* _filter_: finite/infinite impulse response, polyphase, hilbert,
interpolation, decimation, filter design, resampling, symbol
timing recovery
* _framing_: flexible framing structures for amazingly easy packet
software radio; dynamically adjust modulation and coding on the
fly with single and multicarrier framing structures
* _math_: transcendental functions not in the C standard library
(gamma, besseli, etc.), polynomial operations (curvefitting,
rootfinding, etc.)
* _matrix_: basic math, LU/QR/Cholesky factorization, inversion,
Gauss elimination, GramSchmidt decomposition, linear solver,
sparse matrix representation
* _modem_: modulate, demodulate, PSK, differential PSK, QAM, optimal
QAM, as well as analog and nonlinear digital modulations GMSK)
* _multichannel_: filterbank channelizers, OFDM
* _nco_: numericallycontrolled oscillator: mixing, frequency
synthesis, phaselocked loops
* _optim_: (nonlinear optimization) NewtonRaphson, evoluationary
algorithms, gradient descent, line search
* _quantization_: analog/digital converters, compression/expansion
* _random_: (random number generators) uniform, exponential, gamma,
Nakagamim, Gauss, RiceK, Weibull
* _sequence_: linear feedback shift registers, complementary codes,
maximallength sequences
* _utility_: useful miscellany, mostly bit manipulation (shifting,
packing, and unpacking of arrays)
* _vector_: generic vector operations
### License ###
liquid projects are released under the X11/MIT license.
Short version: this code is copyrighted to me (Joseph D. Gaeddert),
I give you permission to do wantever you want with it except remove my name
from the credits. See the LICENSE file or
[http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT)
for specific terms.
