484 lines
13 KiB
C
484 lines
13 KiB
C
/*
|
|
* Copyright 2016 Dominic Spill <dominicgs@gmail.com>
|
|
*
|
|
* This file is part of HackRF.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <hackrf.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <getopt.h>
|
|
#include <string.h>
|
|
|
|
#ifndef bool
|
|
typedef int bool;
|
|
#define true 1
|
|
#define false 0
|
|
#endif
|
|
|
|
#define FREQ_MIN_MHZ (0) /* 0 MHz */
|
|
#define FREQ_MAX_MHZ (7250) /* 7250 MHz */
|
|
|
|
#define INVALID_ADDRESS 0xFF
|
|
#define INVALID_MODE 0xFF
|
|
#define INVALID_PORT 0xFF
|
|
|
|
#define GPIO_TEST_DISABLED 0xFFFF
|
|
|
|
static void usage() {
|
|
printf("\nUsage:\n");
|
|
printf("\t-h, --help: this help\n");
|
|
printf("\t-d, --device <n>: specify a particular device by serial number\n");
|
|
printf("\t-o, --address <n>: specify a particular operacake by address [default: 0]\n");
|
|
printf("\t-m, --mode <mode>: specify switching mode [options: manual, frequency, time]\n");
|
|
printf("\t-a <n>: set port A connection\n");
|
|
printf("\t-b <n>: set port B connection\n");
|
|
printf("\t-f <port:min:max>: automatically assign <port> for range <min:max> in MHz\n");
|
|
printf("\t-t <port:dwell>: in time-switching mode, dwell on <port> for <dwell> samples. Specify only <port> to use the default dwell time (with -w). This argument can be repeated to specify a list of ports.\n");
|
|
printf("\t-w <n>: set default dwell time for time-switching mode\n");
|
|
printf("\t-l, --list: list available operacake boards\n");
|
|
printf("\t-g, --gpio_test: test GPIO functionality of an opera cake\n");
|
|
}
|
|
|
|
static struct option long_options[] = {
|
|
{ "device", required_argument, 0, 'd' },
|
|
{ "address", required_argument, 0, 'o' },
|
|
{ "mode", required_argument, 0, 'm' },
|
|
{ "list", no_argument, 0, 'l' },
|
|
{ "gpio_test", no_argument, 0, 'g' },
|
|
{ "help", no_argument, 0, 'h' },
|
|
{ 0, 0, 0, 0 },
|
|
};
|
|
|
|
int parse_uint16(char* const s, uint16_t* const value) {
|
|
char* s_end = s;
|
|
const long long_value = strtol(s, &s_end, 10);
|
|
if( (s != s_end) && (*s_end == 0) ) {
|
|
*value = (uint16_t)long_value;
|
|
return HACKRF_SUCCESS;
|
|
} else {
|
|
return HACKRF_ERROR_INVALID_PARAM;
|
|
}
|
|
}
|
|
|
|
int parse_uint32(char* const s, uint32_t* const value) {
|
|
char* s_end = s;
|
|
const long long_value = strtol(s, &s_end, 10);
|
|
if( (s != s_end) && (*s_end == 0) ) {
|
|
*value = (uint32_t)long_value;
|
|
return HACKRF_SUCCESS;
|
|
} else {
|
|
return HACKRF_ERROR_INVALID_PARAM;
|
|
}
|
|
}
|
|
|
|
int parse_port(char* str, uint8_t* port) {
|
|
uint16_t tmp_port;
|
|
int result;
|
|
|
|
if(str[0] == 'A' || str[0] == 'B') {
|
|
// The port was specified as a side and number eg. A1 or B3
|
|
result = parse_uint16(str+1, &tmp_port);
|
|
if (result != HACKRF_SUCCESS)
|
|
return result;
|
|
|
|
if(tmp_port >= 5 || tmp_port <= 0) {
|
|
fprintf(stderr, "invalid port: %s\n", str);
|
|
return HACKRF_ERROR_INVALID_PARAM;
|
|
}
|
|
|
|
// Value was a valid port between 0-4
|
|
if(str[0] == 'A') {
|
|
// A1=0, A2=1, A3=2, A4=3
|
|
tmp_port -= 1;
|
|
} else {
|
|
// If B was specfied just add 4-1 ports
|
|
// B1=4, B2=5, B3=6, B4=7
|
|
tmp_port += 3;
|
|
}
|
|
} else {
|
|
result = parse_uint16(str, &tmp_port);
|
|
if (result != HACKRF_SUCCESS)
|
|
return result;
|
|
}
|
|
*port = tmp_port & 0xFF;
|
|
// printf("Port: %d\n", *port);
|
|
return HACKRF_SUCCESS;
|
|
}
|
|
|
|
int parse_range(char* s, hackrf_operacake_freq_range* range) {
|
|
char port[16];
|
|
float min;
|
|
float max;
|
|
int result;
|
|
|
|
// Read frequency as a float here to support scientific notation (e.g: 1e6)
|
|
if (sscanf(s, "%15[^:]:%f:%f", port, &min, &max) == 3) {
|
|
result = parse_port(port, &(range->port));
|
|
if (result != HACKRF_SUCCESS)
|
|
return result;
|
|
|
|
range->freq_min = min;
|
|
range->freq_max = max;
|
|
return HACKRF_SUCCESS;
|
|
}
|
|
return HACKRF_ERROR_INVALID_PARAM;
|
|
}
|
|
|
|
int parse_dwell(char* s, hackrf_operacake_dwell_time* dwell_time) {
|
|
int result;
|
|
char port[16];
|
|
float dwell;
|
|
|
|
// Read dwell as a float here to support scientific notation (e.g: 1e6)
|
|
if (sscanf(s, "%15[^:]:%f", port, &dwell) == 2) {
|
|
result = parse_port(port, &dwell_time->port);
|
|
if (result != HACKRF_SUCCESS)
|
|
return result;
|
|
|
|
if (dwell == 0) {
|
|
fprintf(stderr, "dwell time cannot be 0\n");
|
|
return HACKRF_ERROR_INVALID_PARAM;
|
|
}
|
|
dwell_time->dwell = (uint32_t)dwell;
|
|
return HACKRF_SUCCESS;
|
|
} else if (sscanf(s, "%15[^:]", port) == 1) {
|
|
result = parse_port(port, &dwell_time->port);
|
|
if (result != HACKRF_SUCCESS)
|
|
return result;
|
|
|
|
// This will be replaced with the default dwell time later.
|
|
dwell_time->dwell = 0;
|
|
return HACKRF_SUCCESS;
|
|
}
|
|
return HACKRF_ERROR_INVALID_PARAM;
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
int opt;
|
|
const char* serial_number = NULL;
|
|
uint8_t operacake_address = 0;
|
|
bool set_mode = false;
|
|
uint8_t mode;
|
|
uint8_t port_a = INVALID_PORT;
|
|
uint8_t port_b = INVALID_PORT;
|
|
bool set_ports = false;
|
|
bool list = false;
|
|
bool gpio_test = false;
|
|
uint8_t operacakes[8];
|
|
uint8_t operacake_count = 0;
|
|
int i = 0;
|
|
hackrf_device* device = NULL;
|
|
int option_index = 0;
|
|
hackrf_operacake_freq_range ranges[HACKRF_OPERACAKE_MAX_FREQ_RANGES];
|
|
hackrf_operacake_dwell_time dwell_times[HACKRF_OPERACAKE_MAX_DWELL_TIMES];
|
|
uint8_t range_idx = 0;
|
|
uint8_t dwell_idx = 0;
|
|
uint32_t default_dwell = 0;
|
|
|
|
int result = hackrf_init();
|
|
if( result ) {
|
|
printf("hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result);
|
|
return -1;
|
|
}
|
|
|
|
while( (opt = getopt_long(argc, argv, "d:o:a:m:b:lf:t:w:hg?", long_options, &option_index)) != EOF ) {
|
|
switch( opt ) {
|
|
case 'd':
|
|
serial_number = optarg;
|
|
break;
|
|
|
|
case 'o':
|
|
operacake_address = atoi(optarg);
|
|
break;
|
|
|
|
case 'm':
|
|
if (strcmp(optarg, "manual") == 0) {
|
|
mode = OPERACAKE_MODE_MANUAL;
|
|
set_mode = true;
|
|
} else if (strcmp(optarg, "frequency") == 0) {
|
|
mode = OPERACAKE_MODE_FREQUENCY;
|
|
set_mode = true;
|
|
} else if (strcmp(optarg, "time") == 0) {
|
|
mode = OPERACAKE_MODE_TIME;
|
|
set_mode = true;
|
|
} else {
|
|
fprintf(stderr,
|
|
"argument error: mode must be one of [manual, frequency, time].\n");
|
|
usage();
|
|
return EXIT_FAILURE;
|
|
}
|
|
break;
|
|
|
|
case 'f':
|
|
if (HACKRF_OPERACAKE_MAX_FREQ_RANGES == range_idx) {
|
|
fprintf(stderr,
|
|
"argument error: specify a maximum of %u frequency ranges.\n",
|
|
HACKRF_OPERACAKE_MAX_FREQ_RANGES);
|
|
usage();
|
|
return EXIT_FAILURE;
|
|
}
|
|
result = parse_range(optarg, &ranges[range_idx]);
|
|
if (result != HACKRF_SUCCESS) {
|
|
fprintf(stderr, "failed to parse range\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
if(ranges[range_idx].freq_min >= ranges[range_idx].freq_max) {
|
|
fprintf(stderr,
|
|
"argument error: freq_max must be greater than freq_min.\n");
|
|
usage();
|
|
return EXIT_FAILURE;
|
|
}
|
|
if(FREQ_MAX_MHZ < ranges[range_idx].freq_max) {
|
|
fprintf(stderr,
|
|
"argument error: freq_max may not be higher than %u.\n",
|
|
FREQ_MAX_MHZ);
|
|
usage();
|
|
return EXIT_FAILURE;
|
|
}
|
|
range_idx++;
|
|
break;
|
|
|
|
case 't':
|
|
if(HACKRF_OPERACAKE_MAX_DWELL_TIMES == dwell_idx) {
|
|
fprintf(stderr,
|
|
"argument error: specify a maximum of %u dwell times.\n",
|
|
HACKRF_OPERACAKE_MAX_DWELL_TIMES);
|
|
usage();
|
|
return EXIT_FAILURE;
|
|
}
|
|
result = parse_dwell(optarg, &dwell_times[dwell_idx]);
|
|
if (result != HACKRF_SUCCESS) {
|
|
fprintf(stderr, "failed to parse dwell time\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
dwell_idx++;
|
|
break;
|
|
|
|
case 'w':
|
|
default_dwell = atof(optarg);
|
|
break;
|
|
|
|
case 'a':
|
|
result = parse_port(optarg, &port_a);
|
|
if (result != HACKRF_SUCCESS) {
|
|
fprintf(stderr, "failed to parse port\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
set_ports = true;
|
|
break;
|
|
|
|
case 'b':
|
|
result = parse_port(optarg, &port_b);
|
|
if (result != HACKRF_SUCCESS) {
|
|
fprintf(stderr, "failed to parse port\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
set_ports = true;
|
|
break;
|
|
|
|
case 'l':
|
|
list = true;
|
|
break;
|
|
|
|
case 'g':
|
|
gpio_test = true;
|
|
break;
|
|
|
|
case 'h':
|
|
case '?':
|
|
usage();
|
|
return EXIT_SUCCESS;
|
|
|
|
default:
|
|
fprintf(stderr, "unknown argument '-%c %s'\n", opt, optarg);
|
|
usage();
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
|
|
// Any operations that set a parameter on an Opera Cake board.
|
|
bool set_params = set_mode || set_ports || range_idx || dwell_idx;
|
|
|
|
// Error out unless exactly one option is selected.
|
|
if (list + set_params + gpio_test != 1) {
|
|
fprintf(stderr, "Specify either list, mode, or GPIO test option.\n");
|
|
usage();
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
result = hackrf_open_by_serial(serial_number, &device);
|
|
if (result != HACKRF_SUCCESS) {
|
|
fprintf(stderr, "hackrf_open() failed: %s (%d)\n",
|
|
hackrf_error_name(result), result);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (set_mode) {
|
|
result = hackrf_set_operacake_mode(device, operacake_address, mode);
|
|
if (result != HACKRF_SUCCESS) {
|
|
fprintf(stderr, "hackrf_set_operacake_mode() failed: %s (%d)\n",
|
|
hackrf_error_name(result), result);
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
|
|
if(list) {
|
|
result = hackrf_get_operacake_boards(device, operacakes);
|
|
if (result != HACKRF_SUCCESS) {
|
|
fprintf(stderr, "hackrf_get_operacake_boards() failed: %s (%d)\n",
|
|
hackrf_error_name(result), result);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf("Opera Cakes found: ");
|
|
for(i=0; i<8; i++) {
|
|
if(operacakes[i] != HACKRF_OPERACAKE_ADDRESS_INVALID) {
|
|
printf("\n\tAddress: %d", operacakes[i]);
|
|
enum operacake_switching_mode mode;
|
|
hackrf_get_operacake_mode(device, i, &mode);
|
|
printf("\tSwitching mode: ");
|
|
if (mode == OPERACAKE_MODE_MANUAL) {
|
|
printf("manual\n");
|
|
} else if (mode == OPERACAKE_MODE_FREQUENCY) {
|
|
printf("frequency\n");
|
|
} else if (mode == OPERACAKE_MODE_TIME) {
|
|
printf("time\n");
|
|
} else {
|
|
printf("unknown\n");
|
|
}
|
|
operacake_count++;
|
|
}
|
|
}
|
|
if(!operacake_count)
|
|
printf("None");
|
|
printf("\n");
|
|
}
|
|
|
|
if(gpio_test) {
|
|
uint16_t test_result;
|
|
uint8_t reg, mask = 0x7;
|
|
result = hackrf_operacake_gpio_test(device, operacake_address, &test_result);
|
|
if (result != HACKRF_SUCCESS) {
|
|
fprintf(stderr, "hackrf_operacake_gpio_test() failed: %s (%d)\n",
|
|
hackrf_error_name(result), result);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if(test_result == GPIO_TEST_DISABLED) {
|
|
fprintf(stderr, "GPIO mode diabled.\n");
|
|
fprintf(stderr, "Remove additional addon boards and retry.\n");
|
|
}else if(test_result) {
|
|
fprintf(stderr, "GPIO test failed\n");
|
|
fprintf(stderr, "Pin\tHigh\tShorts\tLow\n");
|
|
reg = test_result & mask;
|
|
fprintf(stderr, "u2ctrl1\t%d\t%d\t%d\n",
|
|
(reg>>2) & 1,
|
|
(reg>>1) & 1,
|
|
reg & 1);
|
|
test_result >>= 3;
|
|
reg = test_result & mask;
|
|
fprintf(stderr, "u2ctrl0\t%d\t%d\t%d\n",
|
|
(reg>>2) & 1,
|
|
(reg>>1) & 1,
|
|
reg & 1);
|
|
test_result >>= 3;
|
|
reg = test_result & mask;
|
|
fprintf(stderr, "u3ctrl1\t%d\t%d\t%d\n",
|
|
(reg>>2) & 1,
|
|
(reg>>1) & 1,
|
|
reg & 1);
|
|
test_result >>= 3;
|
|
reg = test_result & mask;
|
|
fprintf(stderr, "u3ctrl0\t%d\t%d\t%d\n",
|
|
(reg>>2) & 1,
|
|
(reg>>1) & 1,
|
|
reg & 1);
|
|
test_result >>= 3;
|
|
reg = test_result & mask;
|
|
fprintf(stderr, "u1ctrl \t%d\t%d\t%d\n",
|
|
(reg>>2) & 1,
|
|
(reg>>1) & 1,
|
|
reg & 1);
|
|
} else {
|
|
fprintf(stderr, "GPIO test passed\n");
|
|
}
|
|
}
|
|
|
|
if(set_ports) {
|
|
// Set other port to "don't care" if not set
|
|
if(port_a == INVALID_PORT) {
|
|
if(port_b >= 4) {
|
|
port_a = 0;
|
|
} else {
|
|
port_a = 4;
|
|
}
|
|
}
|
|
if(port_b == INVALID_PORT) {
|
|
if(port_a >= 4) {
|
|
port_b = 0;
|
|
} else {
|
|
port_b = 4;
|
|
}
|
|
}
|
|
if(((port_a<=3) && (port_b<=3)) || ((port_a>=4) && (port_b>=4))) {
|
|
fprintf(stderr, "Port A and B cannot be connected to the same side\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
result = hackrf_set_operacake_ports(device, operacake_address, port_a, port_b);
|
|
if( result ) {
|
|
printf("hackrf_set_operacake_ports() failed: %s (%d)\n", hackrf_error_name(result), result);
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
|
|
if (range_idx) {
|
|
result = hackrf_set_operacake_freq_ranges(device, ranges, range_idx);
|
|
if (result) {
|
|
printf("hackrf_set_operacake_freq_ranges() failed: %s (%d)\n", hackrf_error_name(result), result);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if(dwell_idx) {
|
|
for (i = 0; i < dwell_idx; i++) {
|
|
if (dwell_times[i].dwell == 0) {
|
|
if (default_dwell == 0) {
|
|
fprintf(stderr, "port '%u' set to use default dwell time, but default dwell time is not set. Use -w argument to set default dwell time.\n",
|
|
dwell_times[i].port);
|
|
return EXIT_FAILURE;
|
|
}
|
|
dwell_times[i].dwell = default_dwell;
|
|
}
|
|
}
|
|
result = hackrf_set_operacake_dwell_times(device, dwell_times, dwell_idx);
|
|
if( result ) {
|
|
printf("hackrf_set_operacake_dwell_times() failed: %s (%d)\n", hackrf_error_name(result), result);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
result = hackrf_close(device);
|
|
if( result ) {
|
|
printf("hackrf_close() failed: %s (%d)\n", hackrf_error_name(result), result);
|
|
return -1;
|
|
}
|
|
hackrf_exit();
|
|
return 0;
|
|
}
|