OSQZSS
GitHub
commit
b993da884c
3
.gitignore
vendored
3
.gitignore
vendored
@ -38,3 +38,6 @@ gps-sdr-sim-lut
|
||||
|
||||
# Temporary files
|
||||
*.swp
|
||||
|
||||
# Netbeans project folder
|
||||
nbproject/*
|
||||
36
README.md
36
README.md
@ -2,7 +2,7 @@
|
||||
|
||||
GPS-SDR-SIM generates GPS baseband signal data streams, which can be converted
|
||||
to RF using software-defined radio (SDR) platforms, such as
|
||||
[bladeRF](http://nuand.com/), [HackRF](https://github.com/mossmann/hackrf/wiki), and [USRP](http://www.ettus.com/).
|
||||
[ADALM-Pluto](https://wiki.analog.com/university/tools/pluto), [bladeRF](http://nuand.com/), [HackRF](https://github.com/mossmann/hackrf/wiki), and [USRP](http://www.ettus.com/).
|
||||
|
||||
### Windows build instructions
|
||||
|
||||
@ -35,11 +35,11 @@ These files are then used to generate the simulated pseudorange and
|
||||
Doppler for the GPS satellites in view. This simulated range data is
|
||||
then used to generate the digitized I/Q samples for the GPS signal.
|
||||
|
||||
The bladeRF command line interface requires I/Q pairs stored as signed
|
||||
The bladeRF and ADALM-Pluto command line interface requires I/Q pairs stored as signed
|
||||
16-bit integers, while the hackrf_transfer and gps-sdr-sim-uhd.py
|
||||
support signed bytes.
|
||||
|
||||
HackRF and bladeRF require 2.6 MHz sample rate, while the USRP2 requires
|
||||
HackRF, bladeRF and ADALM-Pluto require 2.6 MHz sample rate, while the USRP2 requires
|
||||
2.5 MHz (an even integral decimator of 100 MHz).
|
||||
|
||||
The simulation start time can be specified if the corresponding set of ephemerides
|
||||
@ -91,6 +91,8 @@ The user motion can be specified in either dynamic or static mode:
|
||||
The TX port of a particular SDR platform is connected to the GPS receiver
|
||||
under test through a DC block and a fixed 50-60dB attenuator.
|
||||
|
||||
#### BladeRF
|
||||
|
||||
The simulated GPS signal file, named "gpssim.bin", can be loaded
|
||||
into the bladeRF for playback as shown below:
|
||||
|
||||
@ -106,29 +108,49 @@ tx start
|
||||
```
|
||||
|
||||
You can also execute these commands via the `bladeRF-cli` script option as below:
|
||||
|
||||
```
|
||||
> bladeRF-cli -s bladerf.script
|
||||
```
|
||||
|
||||
For the HackRF:
|
||||
#### HackRF:
|
||||
|
||||
```
|
||||
> hackrf_transfer -t gpssim.bin -f 1575420000 -s 2600000 -a 1 -x 0
|
||||
```
|
||||
|
||||
For UHD supported devices (tested with USRP2 only):
|
||||
#### UHD supported devices (tested with USRP2 only):
|
||||
|
||||
```
|
||||
> gps-sdr-sim-uhd.py -t gpssim.bin -s 2500000 -x 0
|
||||
```
|
||||
|
||||
For LimeSDR (in case of 1 Msps 1-bit file, to get full BaseBand dynamic and low RF power):
|
||||
#### LimeSDR (in case of 1 Msps 1-bit file, to get full BaseBand dynamic and low RF power):
|
||||
|
||||
```
|
||||
> limeplayer -s 1000000 -b 1 -d 2047 -g 0.1 < ../circle.1b.1M.bin
|
||||
```
|
||||
|
||||
#### ADALM-Pluto (PlutoSDR):
|
||||
|
||||
The ADALM-Pluto device is expected to have its network interface up and running and is accessible
|
||||
via "pluto.local" by default.
|
||||
|
||||
Default settings:
|
||||
```
|
||||
> plutoplayer -t gpssim.bin
|
||||
```
|
||||
Set TX attenuation:
|
||||
```
|
||||
> plutoplayer -t gpssim.bin -a -30.0
|
||||
```
|
||||
Default -20.0dB. Applicable range 0.0dB to -80.0dB in 0.25dB steps.
|
||||
|
||||
Set RF bandwidth:
|
||||
```
|
||||
> plutoplayer -t gpssim.bin -b 3.0
|
||||
```
|
||||
Default 3.0MHz. Applicable range 1.0MHz to 5.0MHz.
|
||||
|
||||
### License
|
||||
|
||||
Copyright © 2015 Takuji Ebinuma
|
||||
|
||||
@ -1,5 +1,28 @@
|
||||
CC=gcc -O2 -Wall
|
||||
DIALECT = -std=c11
|
||||
CFLAGS += $(DIALECT) -O3 -g -W -Wall
|
||||
LIBS = -lm
|
||||
|
||||
limeplayer: limeplayer.c
|
||||
$(CC) -o limeplayer limeplayer.c -lLimeSuite
|
||||
CFLAGS += $(shell pkg-config --cflags libbladeRF)
|
||||
CFLAGS += $(shell pkg-config --cflags libhackrf)
|
||||
CFLAGS += $(shell pkg-config --cflags libiio libad9361)
|
||||
|
||||
.PHONY: all bladeplayer hackplayer limeplayer plutoplayer clean
|
||||
all: bladeplayer hackplayer limeplayer plutoplayer
|
||||
|
||||
%.o: %.c *.h
|
||||
$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@
|
||||
|
||||
bladeplayer: bladeplayer.o $(SDR_OBJ) $(COMPAT)
|
||||
$(CC) -g -o $@ $^ $(LDFLAGS) $(LIBS) $(shell pkg-config --libs libbladeRF)
|
||||
|
||||
hackplayer: hackplayer.o $(COMPAT)
|
||||
$(CC) -g -o $@ $^ $(LDFLAGS) $(LIBS) $(shell pkg-config --libs libhackrf)
|
||||
|
||||
limeplayer: limeplayer.o $(COMPAT)
|
||||
$(CC) -g -o $@ $^ $(LDFLAGS) $(LIBS) -lLimeSuite
|
||||
|
||||
plutoplayer: plutoplayer.o $(COMPAT)
|
||||
$(CC) -g -o $@ $^ $(LDFLAGS) $(LIBS) $(shell pkg-config --libs libiio libad9361)
|
||||
|
||||
clean:
|
||||
rm -f *.o bladeplayer hackplayer limeplayer plutoplayer
|
||||
|
||||
82
player/README.md
Normal file
82
player/README.md
Normal file
@ -0,0 +1,82 @@
|
||||
## Building
|
||||
|
||||
Modified to build on Linux.
|
||||
|
||||
```
|
||||
$ make all
|
||||
```
|
||||
Will build all players if dependencies are met.
|
||||
|
||||
### Dependencies - bladeRF
|
||||
#### libbladeRF
|
||||
```
|
||||
$ git clone https://github.com/Nuand/bladeRF.git
|
||||
$ cd bladeRF
|
||||
$ dpkg-buildpackage -b
|
||||
```
|
||||
Or Nuand has some build/install instructions including an Ubuntu PPA
|
||||
at https://github.com/Nuand/bladeRF/wiki/Getting-Started:-Linux
|
||||
|
||||
#### Build
|
||||
|
||||
```
|
||||
$ make bladeplayer
|
||||
```
|
||||
|
||||
### Dependecies - hackRF
|
||||
#### libhackrf
|
||||
|
||||
```
|
||||
> git clone https://github.com/mossmann/hackrf.git
|
||||
> mkdir hackrf/host/build
|
||||
> cd hackrf/host/build
|
||||
> cmake ..
|
||||
> make
|
||||
> sudo make install
|
||||
> sudo ldconfig
|
||||
```
|
||||
Build instructions https://github.com/mossmann/hackrf/tree/master/host
|
||||
|
||||
#### Build
|
||||
|
||||
```
|
||||
> make hackplayer
|
||||
```
|
||||
|
||||
### Dependecies - lime
|
||||
|
||||
LimeSuite https://github.com/myriadrf/LimeSuite
|
||||
|
||||
Build instructions http://wiki.myriadrf.org/Lime_Suite
|
||||
|
||||
:exclamation: Build not tested.
|
||||
|
||||
### Dependecies - ADALM-Pluto
|
||||
#### libiio
|
||||
|
||||
Use the latest version from Github.
|
||||
```
|
||||
$ git clone https://github.com/analogdevicesinc/libiio.git
|
||||
$ cd libiio
|
||||
$ cmake ./
|
||||
$ make all
|
||||
$ sudo make install
|
||||
```
|
||||
[How to build it in detail.](https://wiki.analog.com/resources/tools-software/linux-software/libiio)
|
||||
|
||||
#### libad9361
|
||||
|
||||
Use of the latest Github version mandatory.
|
||||
```
|
||||
$ git clone https://github.com/analogdevicesinc/libad9361-iio.git
|
||||
$ cd libad9361-iio
|
||||
$ cmake ./
|
||||
$ make all
|
||||
$ sudo make install
|
||||
```
|
||||
|
||||
#### Build
|
||||
|
||||
```
|
||||
$ make plutoplayer
|
||||
```
|
||||
@ -4,11 +4,8 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <libbladeRF.h>
|
||||
#ifdef _WIN32
|
||||
#include "getopt.h"
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#include <errno.h>
|
||||
|
||||
#define TX_FREQUENCY 1575420000
|
||||
#define TX_SAMPLERATE 2600000
|
||||
@ -23,8 +20,7 @@
|
||||
|
||||
#define AMPLITUDE (1000) // Default amplitude for 12-bit I/Q
|
||||
|
||||
void usage(void)
|
||||
{
|
||||
void usage(void) {
|
||||
fprintf(stderr, "Usage: bladeplayer [options]\n"
|
||||
" -f <tx_file> I/Q sampling data file (required)\n"
|
||||
" -b <iq_bits> I/Q data format [1/16] (default: 16)\n"
|
||||
@ -33,15 +29,18 @@ void usage(void)
|
||||
|
||||
return;
|
||||
}
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
int status;
|
||||
char *devstr = NULL;
|
||||
struct bladerf *dev = NULL;
|
||||
|
||||
FILE *fp;
|
||||
int16_t *tx_buffer;
|
||||
enum state {INIT, READ_FILE, PAD_TRAILING, DONE};
|
||||
|
||||
enum state {
|
||||
INIT, READ_FILE, PAD_TRAILING, DONE
|
||||
};
|
||||
enum state state = INIT;
|
||||
|
||||
int compressed = 0;
|
||||
@ -49,7 +48,7 @@ int main(int argc, char *argv[])
|
||||
size_t samples_read;
|
||||
int16_t lut[256][8];
|
||||
int16_t amp = AMPLITUDE;
|
||||
int i,k;
|
||||
uint32_t i, k;
|
||||
|
||||
int gain = TX_VGA1;
|
||||
int result;
|
||||
@ -64,26 +63,21 @@ int main(int argc, char *argv[])
|
||||
exit(1);
|
||||
}
|
||||
|
||||
while ((result=getopt(argc,argv,"g:b:f:"))!=-1)
|
||||
{
|
||||
switch (result)
|
||||
{
|
||||
while ((result = getopt(argc, argv, "g:b:f:")) != -1) {
|
||||
switch (result) {
|
||||
case 'g':
|
||||
gain = atoi(optarg);
|
||||
if (gain>-4 || gain<-35)
|
||||
{
|
||||
if (gain>-4 || gain<-35) {
|
||||
printf("ERROR: Invalid TX VGA1 gain.\n");
|
||||
exit(1);
|
||||
}
|
||||
break;
|
||||
case 'b':
|
||||
data_format = atoi(optarg);
|
||||
if (data_format!=1 && data_format!=16)
|
||||
{
|
||||
if (data_format != 1 && data_format != 16) {
|
||||
printf("ERROR: Invalid I/Q data format.\n");
|
||||
exit(1);
|
||||
}
|
||||
else if (data_format==1)
|
||||
} else if (data_format == 1)
|
||||
compressed = 1;
|
||||
break;
|
||||
case 'f':
|
||||
@ -99,8 +93,7 @@ int main(int argc, char *argv[])
|
||||
}
|
||||
|
||||
// Open TX file.
|
||||
if (txfile[0]==0)
|
||||
{
|
||||
if (txfile[0] == 0) {
|
||||
printf("ERROR: I/Q sampling data file is not specified.\n");
|
||||
exit(1);
|
||||
}
|
||||
@ -134,8 +127,7 @@ int main(int argc, char *argv[])
|
||||
if (status != 0) {
|
||||
fprintf(stderr, "Failed to set TX sample rate: %s\n", bladerf_strerror(status));
|
||||
goto out;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
printf("TX sample rate: %u sps\n", TX_SAMPLERATE);
|
||||
}
|
||||
|
||||
@ -143,8 +135,7 @@ int main(int argc, char *argv[])
|
||||
if (status != 0) {
|
||||
fprintf(stderr, "Failed to set TX bandwidth: %s\n", bladerf_strerror(status));
|
||||
goto out;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
printf("TX bandwidth: %u Hz\n", TX_BANDWIDTH);
|
||||
}
|
||||
|
||||
@ -152,8 +143,7 @@ int main(int argc, char *argv[])
|
||||
if (status != 0) {
|
||||
fprintf(stderr, "Failed to set TX VGA1 gain: %s\n", bladerf_strerror(status));
|
||||
goto out;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
printf("TX VGA1 gain: %d dB\n", gain);
|
||||
}
|
||||
|
||||
@ -161,8 +151,7 @@ int main(int argc, char *argv[])
|
||||
if (status != 0) {
|
||||
fprintf(stderr, "Failed to set TX VGA2 gain: %s\n", bladerf_strerror(status));
|
||||
goto out;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
printf("TX VGA2 gain: %d dB\n", TX_VGA2);
|
||||
}
|
||||
|
||||
@ -185,8 +174,7 @@ int main(int argc, char *argv[])
|
||||
goto out;
|
||||
}
|
||||
|
||||
for (i=0; i<256; i++)
|
||||
{
|
||||
for (i = 0; i < 256; i++) {
|
||||
for (k = 0; k < 8; k++)
|
||||
lut[i][k] = ((i >> (7 - k))&0x1) ? amp : -amp;
|
||||
}
|
||||
@ -229,8 +217,7 @@ int main(int argc, char *argv[])
|
||||
case INIT:
|
||||
case READ_FILE:
|
||||
// Read from the input file
|
||||
if (compressed)
|
||||
{
|
||||
if (compressed) {
|
||||
int16_t *write_buffer_current = tx_buffer;
|
||||
|
||||
samples_read = fread(read_buffer,
|
||||
@ -242,16 +229,13 @@ int main(int argc, char *argv[])
|
||||
buffer_samples_remaining = read_samples_remaining * 4;
|
||||
|
||||
// Expand compressed data into TX buffer
|
||||
for (i=0; i<samples_read; i++)
|
||||
{
|
||||
for (i = 0; i < samples_read; i++) {
|
||||
memcpy(write_buffer_current, lut[read_buffer[i]], 8);
|
||||
|
||||
// Advance the write buffer pointer
|
||||
write_buffer_current += 8;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
samples_populated = fread(tx_buffer_current,
|
||||
2 * sizeof (int16_t),
|
||||
buffer_samples_remaining,
|
||||
@ -261,8 +245,7 @@ int main(int argc, char *argv[])
|
||||
// If the end of the file was reached, pad the rest of the buffer and finish.
|
||||
if (feof(fp)) {
|
||||
state = PAD_TRAILING;
|
||||
}
|
||||
// Check for errors
|
||||
} // Check for errors
|
||||
else if (ferror(fp)) {
|
||||
status = errno;
|
||||
}
|
||||
|
||||
@ -1,22 +1,10 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
|
||||
#include <hackrf.h>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/types.h>
|
||||
#include <getopt.h>
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
#ifdef _WIN64
|
||||
typedef int64_t ssize_t;
|
||||
#else
|
||||
typedef int32_t ssize_t;
|
||||
#endif
|
||||
|
||||
typedef int bool;
|
||||
#define true 1
|
||||
#define false 0
|
||||
#include <signal.h>
|
||||
#include <hackrf.h>
|
||||
|
||||
static hackrf_device* device = NULL;
|
||||
|
||||
@ -25,27 +13,19 @@ volatile uint32_t byte_count = 0;
|
||||
|
||||
volatile bool do_exit = false;
|
||||
|
||||
static transceiver_mode_t transceiver_mode = TRANSCEIVER_MODE_TX;
|
||||
|
||||
#define FD_BUFFER_SIZE (8*1024)
|
||||
#define FREQ_ONE_MHZ (1000000ull)
|
||||
|
||||
BOOL WINAPI sighandler(int signum)
|
||||
{
|
||||
if (CTRL_C_EVENT == signum) {
|
||||
static void sighandler(int signum) {
|
||||
fprintf(stdout, "Caught signal %d\n", signum);
|
||||
do_exit = true;
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
int tx_callback(hackrf_transfer* transfer) {
|
||||
size_t bytes_to_read;
|
||||
|
||||
if( fd != NULL )
|
||||
{
|
||||
ssize_t bytes_read;
|
||||
if (fd != NULL) {
|
||||
size_t bytes_read;
|
||||
byte_count += transfer->valid_length;
|
||||
bytes_to_read = transfer->valid_length;
|
||||
|
||||
@ -78,11 +58,9 @@ int main(int argc, char** argv) {
|
||||
uint64_t freq_hz = 1575420000;
|
||||
uint32_t amp_enable = 1;
|
||||
|
||||
while( (opt = getopt(argc, argv, "t:")) != EOF )
|
||||
{
|
||||
while ((opt = getopt(argc, argv, "t:")) != EOF) {
|
||||
result = HACKRF_SUCCESS;
|
||||
switch( opt )
|
||||
{
|
||||
switch (opt) {
|
||||
case 't':
|
||||
path = optarg;
|
||||
break;
|
||||
@ -136,7 +114,7 @@ int main(int argc, char** argv) {
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
|
||||
signal(SIGINT, sighandler);
|
||||
|
||||
printf("call hackrf_sample_rate_set(%.03f MHz)\n", ((float) sample_rate_hz / (float) FREQ_ONE_MHZ));
|
||||
result = hackrf_set_sample_rate_manual(device, sample_rate_hz, 1);
|
||||
@ -201,8 +179,7 @@ int main(int argc, char** argv) {
|
||||
}
|
||||
|
||||
result = hackrf_close(device);
|
||||
if( result != HACKRF_SUCCESS )
|
||||
{
|
||||
if (result != HACKRF_SUCCESS) {
|
||||
printf("hackrf_close() failed: %s (%d)\n", hackrf_error_name(result), result);
|
||||
} else {
|
||||
printf("hackrf_close() done\n");
|
||||
|
||||
234
player/plutoplayer.c
Normal file
234
player/plutoplayer.c
Normal file
@ -0,0 +1,234 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <getopt.h>
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
#include <string.h>
|
||||
#include <iio.h>
|
||||
#include <ad9361.h>
|
||||
|
||||
#define NOTUSED(V) ((void) V)
|
||||
#define MHZ(x) ((long long)(x*1000000.0 + .5))
|
||||
#define GHZ(x) ((long long)(x*1000000000.0 + .5))
|
||||
#define NUM_SAMPLES 2600000
|
||||
#define BUFFER_SIZE (NUM_SAMPLES * 2 * sizeof(int16_t))
|
||||
|
||||
|
||||
struct stream_cfg {
|
||||
long long bw_hz; // Analog banwidth in Hz
|
||||
long long fs_hz; // Baseband sample rate in Hz
|
||||
long long lo_hz; // Local oscillator frequency in Hz
|
||||
const char* rfport; // Port name
|
||||
double gain_db; // Hardware gain
|
||||
};
|
||||
|
||||
static void usage() {
|
||||
fprintf(stderr, "Usage: plutoplayer [options]\n"
|
||||
" -t <filename> Transmit data from file (required)\n"
|
||||
" -a <attenuation> Set TX attenuation [dB] (default -20.0)"
|
||||
" -b <bw> Set RF bandwidth [MHz] (default 5.0)");
|
||||
return;
|
||||
}
|
||||
|
||||
static bool stop = false;
|
||||
|
||||
static void handle_sig(int sig)
|
||||
{
|
||||
NOTUSED(sig);
|
||||
stop = true;
|
||||
}
|
||||
|
||||
static char* readable_fs(double size, char *buf, size_t buf_size) {
|
||||
int i = 0;
|
||||
const char* units[] = {"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
|
||||
while (size > 1024) {
|
||||
size /= 1024;
|
||||
i++;
|
||||
}
|
||||
snprintf(buf, buf_size, "%.*f %s", i, size, units[i]);
|
||||
return buf;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
int main(int argc, char** argv) {
|
||||
char buf[1024];
|
||||
int opt;
|
||||
const char* path = NULL;
|
||||
struct stream_cfg txcfg;
|
||||
FILE *fp = NULL;
|
||||
enum state {INIT, READ_FILE, PAD_TRAILING, DONE};
|
||||
|
||||
// TX stream default config
|
||||
txcfg.bw_hz = MHZ(3.0); // 3.0 MHz RF bandwidth
|
||||
txcfg.fs_hz = MHZ(2.6); // 2.6 MS/s TX sample rate
|
||||
txcfg.lo_hz = GHZ(1.575420); // 1.57542 GHz RF frequency
|
||||
txcfg.rfport = "A";
|
||||
txcfg.gain_db = -20.0;
|
||||
|
||||
struct iio_context *ctx = NULL;
|
||||
struct iio_device *tx = NULL;
|
||||
struct iio_device *phydev = NULL;
|
||||
struct iio_channel *tx0_i = NULL;
|
||||
struct iio_channel *tx0_q = NULL;
|
||||
struct iio_buffer *tx_buffer = NULL;
|
||||
|
||||
while ((opt = getopt(argc, argv, "t:a:b:")) != EOF) {
|
||||
switch (opt) {
|
||||
case 't':
|
||||
path = optarg;
|
||||
break;
|
||||
case 'a':
|
||||
txcfg.gain_db = atof(optarg);
|
||||
if(txcfg.gain_db > 0.0) txcfg.gain_db = 0.0;
|
||||
if(txcfg.gain_db < -80.0) txcfg.gain_db = -80.0;
|
||||
break;
|
||||
case 'b':
|
||||
txcfg.bw_hz = MHZ(atof(optarg));
|
||||
if(txcfg.bw_hz > MHZ(5.0)) txcfg.bw_hz = MHZ(5.0);
|
||||
if(txcfg.bw_hz < MHZ(1.0)) txcfg.bw_hz = MHZ(1.0);
|
||||
break;
|
||||
default:
|
||||
printf("Unknown argument '-%c %s'\n", opt, optarg);
|
||||
usage();
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
}
|
||||
|
||||
signal(SIGINT, handle_sig);
|
||||
|
||||
if( path == NULL ) {
|
||||
printf("Specify a path to a file to transmit\n");
|
||||
usage();
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
fp = fopen(path, "rb");
|
||||
if (fp==NULL) {
|
||||
fprintf(stderr, "ERROR: Failed to open TX file: %s\n", path);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
fseek(fp, 0L, SEEK_END);
|
||||
size_t sz = ftell(fp);
|
||||
fseek(fp, 0L, SEEK_SET);
|
||||
readable_fs((double)sz, buf, sizeof(buf));
|
||||
printf("* Transmit file size: %s\n", buf);
|
||||
|
||||
printf("* Acquiring IIO context\n");
|
||||
ctx = iio_create_default_context();
|
||||
if (ctx == NULL) {
|
||||
ctx = iio_create_network_context("pluto.local");
|
||||
}
|
||||
|
||||
if (ctx == NULL) {
|
||||
iio_strerror(errno, buf, sizeof(buf));
|
||||
fprintf(stderr, "Failed creating IIO context: %s\n", buf);
|
||||
return false;
|
||||
}
|
||||
|
||||
struct iio_scan_context *scan_ctx;
|
||||
struct iio_context_info **info;
|
||||
scan_ctx = iio_create_scan_context(NULL, 0);
|
||||
if (scan_ctx) {
|
||||
int info_count = iio_scan_context_get_info_list(scan_ctx, &info);
|
||||
if(info_count > 0) {
|
||||
printf("* Found %s\n", iio_context_info_get_description(info[0]));
|
||||
iio_context_info_list_free(info);
|
||||
}
|
||||
iio_scan_context_destroy(scan_ctx);
|
||||
}
|
||||
|
||||
printf("* Acquiring devices\n");
|
||||
int device_count = iio_context_get_devices_count(ctx);
|
||||
if (!device_count) {
|
||||
fprintf(stderr, "No supported PLUTOSDR devices found.\n");
|
||||
goto error_exit;
|
||||
}
|
||||
fprintf(stderr, "* Context has %d device(s).\n", device_count);
|
||||
|
||||
printf("* Acquiring TX device\n");
|
||||
tx = iio_context_find_device(ctx, "cf-ad9361-dds-core-lpc");
|
||||
if (tx == NULL) {
|
||||
iio_strerror(errno, buf, sizeof(buf));
|
||||
fprintf(stderr, "Error opening PLUTOSDR TX device: %s\n", buf);
|
||||
goto error_exit;
|
||||
}
|
||||
|
||||
iio_device_set_kernel_buffers_count(tx, 8);
|
||||
|
||||
phydev = iio_context_find_device(ctx, "ad9361-phy");
|
||||
struct iio_channel* phy_chn = iio_device_find_channel(phydev, "voltage0", true);
|
||||
iio_channel_attr_write(phy_chn, "rf_port_select", txcfg.rfport);
|
||||
iio_channel_attr_write_longlong(phy_chn, "rf_bandwidth", txcfg.bw_hz);
|
||||
iio_channel_attr_write_longlong(phy_chn, "sampling_frequency", txcfg.fs_hz);
|
||||
iio_channel_attr_write_double(phy_chn, "hardwaregain", txcfg.gain_db);
|
||||
|
||||
iio_channel_attr_write_bool(
|
||||
iio_device_find_channel(phydev, "altvoltage0", true)
|
||||
, "powerdown", true); // Turn OFF RX LO
|
||||
|
||||
iio_channel_attr_write_longlong(
|
||||
iio_device_find_channel(phydev, "altvoltage1", true)
|
||||
, "frequency", txcfg.lo_hz); // Set TX LO frequency
|
||||
|
||||
iio_channel_attr_write_longlong(
|
||||
iio_device_find_channel(phydev, "altvoltage1", true)
|
||||
, "frequency", txcfg.lo_hz); // Set TX LO frequency
|
||||
|
||||
printf("* Initializing streaming channels\n");
|
||||
tx0_i = iio_device_find_channel(tx, "voltage0", true);
|
||||
if (!tx0_i)
|
||||
tx0_i = iio_device_find_channel(tx, "altvoltage0", true);
|
||||
|
||||
tx0_q = iio_device_find_channel(tx, "voltage1", true);
|
||||
if (!tx0_q)
|
||||
tx0_q = iio_device_find_channel(tx, "altvoltage1", true);
|
||||
|
||||
printf("* Enabling IIO streaming channels\n");
|
||||
iio_channel_enable(tx0_i);
|
||||
iio_channel_enable(tx0_q);
|
||||
|
||||
ad9361_set_bb_rate(iio_context_find_device(ctx, "ad9361-phy"), txcfg.fs_hz);
|
||||
|
||||
printf("* Creating TX buffer\n");
|
||||
|
||||
tx_buffer = iio_device_create_buffer(tx, NUM_SAMPLES, false);
|
||||
if (!tx_buffer) {
|
||||
fprintf(stderr, "Could not create TX buffer.\n");
|
||||
goto error_exit;
|
||||
}
|
||||
|
||||
iio_channel_attr_write_bool(
|
||||
iio_device_find_channel(iio_context_find_device(ctx, "ad9361-phy"), "altvoltage1", true)
|
||||
, "powerdown", false); // Turn ON TX LO
|
||||
|
||||
int32_t ntx = 0;
|
||||
char *ptx_buffer = (char *)iio_buffer_start(tx_buffer);
|
||||
|
||||
printf("* Transmit starts...\n");
|
||||
// Keep writing samples while there is more data to send and no failures have occurred.
|
||||
while (!feof(fp) && !stop) {
|
||||
fread(ptx_buffer, 1, BUFFER_SIZE,fp);
|
||||
// Schedule TX buffer
|
||||
ntx = iio_buffer_push(tx_buffer);
|
||||
if (ntx < 0) {
|
||||
printf("Error pushing buf %d\n", (int) ntx);
|
||||
goto error_exit;
|
||||
}
|
||||
}
|
||||
printf("Done.\n");
|
||||
|
||||
error_exit:
|
||||
fclose(fp);
|
||||
iio_channel_attr_write_bool(
|
||||
iio_device_find_channel(iio_context_find_device(ctx, "ad9361-phy"), "altvoltage1", true)
|
||||
, "powerdown", true); // Turn OFF TX LO
|
||||
|
||||
if (tx_buffer) { iio_buffer_destroy(tx_buffer); }
|
||||
if (tx0_i) { iio_channel_disable(tx0_i); }
|
||||
if (tx0_q) { iio_channel_disable(tx0_q); }
|
||||
if (ctx) { iio_context_destroy(ctx); }
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user