bladeRF/host/utilities/bladeRF-cli/src/cmd/trigger.c
2016-05-22 19:20:27 -04:00

233 lines
6.6 KiB
C

/*
* This file is part of the bladeRF project
*
* Copyright (C) 2015-2016 Nuand LLC
*
* 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 of the License, 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; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include "common.h"
#include "conversions.h"
#include <string.h>
int print_trigger(struct cli_state *state,
bladerf_module module, bladerf_trigger_signal signal)
{
int status;
struct bladerf_trigger t;
bool master, armed, fired, fire_req;
const char *sig_str, *role_str, *module_str;
status = bladerf_trigger_init(state->dev, module, signal, &t);
if (status != 0) {
goto out;
}
status = bladerf_trigger_state(state->dev, &t,
&armed, &fired, &fire_req, NULL, NULL);
if (status != 0) {
goto out;
}
printf("\n");
master = (t.role == BLADERF_TRIGGER_ROLE_MASTER);
role_str = triggerrole2str(t.role);
sig_str = trigger2str(signal);
module_str = module2str(module);
printf(" %s %s trigger\n", sig_str, module_str);
printf(" State: %s\n", armed ? "Armed" : "Disarmed");
printf(" Role: %s\n", role_str);
if (master) {
printf(" Fire Requested: %s\n", fire_req ? "Yes" : "No");
}
printf(" Fired: %s\n", fired ? "Yes" : "No");
printf("\n");
out:
if (status != 0) {
state->last_lib_error = status;
return CLI_RET_LIBBLADERF;
}
return status;
}
static inline int config_trigger(struct cli_state *state,
bladerf_module module,
bladerf_trigger_signal signal,
const char *cmd, const char *argv0)
{
int status;
struct bladerf_trigger trigger;
bool armed, fired, fire_req, master;
const char *module_str, *sig_str;
/* Dissect current value to print certain warnings */
status = bladerf_trigger_init(state->dev, module, signal, &trigger);
if (status != 0) {
goto out;
}
status = bladerf_trigger_state(state->dev, &trigger,
&armed, &fired, &fire_req, NULL, NULL);
if (status != 0) {
goto out;
}
master = (trigger.role == BLADERF_TRIGGER_ROLE_MASTER);
module_str = module2str(module);
sig_str = trigger2str(signal);
if (!strcasecmp(cmd, "off") || !strcasecmp(cmd, "disable") || !strcasecmp(cmd, "disabled")) {
/* Disarm trigger and restore it to a slave role */
trigger.role = BLADERF_TRIGGER_ROLE_DISABLED;
status = bladerf_trigger_arm(state->dev, &trigger, false, 0, 0);
if (status != 0) {
goto out;
}
printf("\n %s %s trigger disabled\n\n", sig_str, module_str);
} else if (!strcasecmp(cmd, "slave")) {
if (fired) {
printf("\n WARNING: Trigger signal is already asserted; trigger will fire immediately.\n");
}
if (master && fire_req) {
printf("\n WARNING: Fire request on this master was active. Changing from master to slave will stop other triggered slaves.\n");
}
trigger.role = BLADERF_TRIGGER_ROLE_SLAVE;
status = bladerf_trigger_arm(state->dev, &trigger, true, 0, 0);
if (status != 0) {
goto out;
}
printf("\n %s %s trigger armed as a slave.\n\n",
sig_str, module_str);
} else if (!strcasecmp(cmd, "master")) {
if (armed && !master) {
printf("\n WARNING: Changing from slave to master. Ensure there is only one master in the trigger chain!\n");
}
trigger.role = BLADERF_TRIGGER_ROLE_MASTER;
status = bladerf_trigger_arm(state->dev, &trigger, true, 0, 0);
if (status != 0) {
goto out;
}
printf("\n %s %s trigger armed as master.\n\n",
sig_str, module_str);
} else if (!strcasecmp(cmd, "fire")) {
if (!(armed && master)) {
cli_err(state, argv0,
"%s %s trigger not configured as master, can't fire\n",
sig_str, module_str);
return CLI_RET_INVPARAM;
}
if (fired) {
printf("\n WARNING: Trigger already fired. Ignoring fire request.\n\n");
return 0;
}
status = bladerf_trigger_fire(state->dev, &trigger);
if (status != 0) {
goto out;
}
printf("\n %s %s trigger fire request submitted successfully.\n\n",
sig_str, module_str);
} else {
cli_err(state, cmd, "Invalid trigger command.\n");
return CLI_RET_INVPARAM;
}
out:
if (status != 0) {
state->last_lib_error = status;
status = CLI_RET_LIBBLADERF;
}
return status;
}
static inline int print_all_triggers(struct cli_state *state)
{
int status;
status = print_trigger(state, BLADERF_MODULE_RX, BLADERF_TRIGGER_J71_4);
if (status != 0) {
return status;
}
status = print_trigger(state, BLADERF_MODULE_TX, BLADERF_TRIGGER_J71_4);
return status;
}
int cmd_trigger(struct cli_state *state, int argc, char **argv)
{
int status = 0;
bladerf_module m;
bladerf_trigger_signal s;
switch (argc) {
case 1:
status = print_all_triggers(state);
break;
case 3:
case 4:
s = str2trigger(argv[1]);
if (s == BLADERF_TRIGGER_INVALID) {
cli_err(state, "Invalid trigger signal", "%s\n", argv[1]);
return CLI_RET_INVPARAM;
}
m = str2module(argv[2]);
if (m == BLADERF_MODULE_INVALID) {
cli_err(state, "Invalid module", "%s\n", argv[2]);
return CLI_RET_INVPARAM;
}
if (argc == 3) {
status = print_trigger(state, m, s);
} else {
status = config_trigger(state, m, s, argv[3], argv[0]);
}
break;
default:
status = CLI_RET_NARGS;
}
return status;
}