963 lines
30 KiB
Matlab
963 lines
30 KiB
Matlab
% A simple bladeRF demo GUI that receives and plots samples
|
|
%
|
|
% Once the GUI starts, select a device from the dropdown of available
|
|
% devices, and then click "start" to begin streaming samples.
|
|
%
|
|
% The various GUI widgets may be used to change the plot mode, frequency,
|
|
% gains, correction values, sample rate, and LPF bandwidth.
|
|
%
|
|
% Note that stream settings may only be changed whe the device is not
|
|
% actively streaming.
|
|
|
|
%
|
|
% Copyright (c) 2015 Nuand LLC
|
|
%
|
|
% Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
% of this software and associated documentation files (the "Software"), to deal
|
|
% in the Software without restriction, including without limitation the rights
|
|
% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
% copies of the Software, and to permit persons to whom the Software is
|
|
% furnished to do so, subject to the following conditions:
|
|
%
|
|
% The above copyright notice and this permission notice shall be included in
|
|
% all copies or substantial portions of the Software.
|
|
%
|
|
% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
% THE SOFTWARE.
|
|
%
|
|
|
|
function varargout = bladeRF_fft(varargin)
|
|
gui_Singleton = 1;
|
|
gui_State = struct('gui_Name', mfilename, ...
|
|
'gui_Singleton', gui_Singleton, ...
|
|
'gui_OpeningFcn', @bladeRF_fft_OpeningFcn, ...
|
|
'gui_OutputFcn', @bladeRF_fft_OutputFcn, ...
|
|
'gui_LayoutFcn', [] , ...
|
|
'gui_Callback', []);
|
|
|
|
if nargin && ischar(varargin{1})
|
|
gui_State.gui_Callback = str2func(varargin{1});
|
|
end
|
|
|
|
if nargout
|
|
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
|
|
else
|
|
gui_mainfcn(gui_State, varargin{:});
|
|
end
|
|
end
|
|
|
|
function set_agc_selection(agc_widget, handles, value)
|
|
strings = agc_widget.String;
|
|
|
|
if strcmpi(value, 'manual')
|
|
handles.gain1.Enable = 'on';
|
|
else
|
|
handles.gain1.Enable = 'off';
|
|
end
|
|
|
|
for n = 1:length(strings)
|
|
if strcmpi(value,strings{n})
|
|
agc_widget.Value = n;
|
|
end
|
|
end
|
|
end
|
|
|
|
function set_bandwidth_selection(bandwidth_widget, value)
|
|
strings = bandwidth_widget.String;
|
|
|
|
for n = 1:length(strings)
|
|
if value == (str2num(strings{n}) * 1e6)
|
|
bandwidth_widget.Value = n;
|
|
end
|
|
end
|
|
end
|
|
|
|
function set_lnagain_selection(lnagain_widget, value)
|
|
strings = lnagain_widget.String;
|
|
for n = 1:length(strings)
|
|
if strcmpi(strings{n}, value)
|
|
lnagain_widget.Value = n;
|
|
end
|
|
end
|
|
end
|
|
|
|
function update_plot_selection(hObject, handles)
|
|
plots = get_plots(hObject);
|
|
|
|
id = handles.displaytype.Value;
|
|
if id < 1 || id > length(plots)
|
|
error('Bug: Got invalid display type ID');
|
|
end
|
|
|
|
for n = 1:length(plots)
|
|
if n == id
|
|
for l = 1:length(plots{n}.lines)
|
|
plots{n}.lines(l).Visible = 'on';
|
|
%fprintf('plot %s ch %d = %s\n', plots{n}.name, l, plots{n}.lines(l).Visible);
|
|
end
|
|
else
|
|
for l = 1:length(plots{n}.lines)
|
|
plots{n}.lines(l).Visible = 'off';
|
|
%fprintf('plot %s ch %d = %s\n', plots{n}.name, l, plots{n}.lines(l).Visible);
|
|
end
|
|
end
|
|
end
|
|
|
|
num_samples = get_num_samples(hObject);
|
|
|
|
% Reset data so we don't see "random" junk when switching displays
|
|
switch plots{id}.name
|
|
case { 'FFT (dB)', 'FFT (linear)' }
|
|
x = linspace(double(plots{id}.xmin), double(plots{id}.xmax), num_samples);
|
|
plots{id}.lines(1).XData = x;
|
|
plots{id}.lines(1).YData = zeros(num_samples, 1) - plots{id}.ymin;
|
|
|
|
case 'Time (2-Channel)'
|
|
x = linspace(double(plots{id}.xmin), double(plots{id}.xmax), num_samples);
|
|
|
|
plots{id}.lines(1).XData = x;
|
|
plots{id}.lines(1).YData = zeros(num_samples, 1);
|
|
|
|
plots{id}.lines(2).XData = x;
|
|
plots{id}.lines(2).YData = zeros(num_samples, 1);
|
|
|
|
case 'Time (XY)'
|
|
plots{id}.lines(1).XData = zeros(num_samples, 1);
|
|
plots{id}.lines(1).YData = zeros(num_samples, 1);
|
|
end
|
|
|
|
% Update the axes limits for this plot
|
|
handles.axes1.XLim = [plots{id}.xmin plots{id}.xmax];
|
|
handles.axes1.YLim = [plots{id}.ymin plots{id}.ymax];
|
|
|
|
% Update the axis labels
|
|
xlabel(handles.axes1, plots{id}.xlabel);
|
|
ylabel(handles.axes1, plots{id}.ylabel);
|
|
end
|
|
|
|
% Get the handle to the GUI's root object
|
|
function [root] = get_root_object(hObject)
|
|
if strcmp(hObject.Type, 'root')
|
|
root = hObject;
|
|
else
|
|
root = get_root_object(hObject.Parent);
|
|
end
|
|
end
|
|
|
|
% Get the state of the 'Enable Biastee' flag
|
|
function [enable_biastee] = get_enable_biastee(hObject)
|
|
root = get_root_object(hObject);
|
|
enable_biastee = getappdata(root, 'enable_biastee');
|
|
if isempty(enable_biastee)
|
|
error('Failed to access app data: enable_biastee');
|
|
end
|
|
end
|
|
|
|
% Set the state of the 'Enable Biastree' flag
|
|
function set_enable_biastee(handles, hObject, value)
|
|
handles.bladerf.rx.biastee = value;
|
|
root = get_root_object(hObject);
|
|
setappdata(root, 'enable_biastee', value);
|
|
end
|
|
|
|
% Get the state of the 'Print Overruns' flag
|
|
function [print_overruns] = get_print_overruns(hObject)
|
|
root = get_root_object(hObject);
|
|
print_overruns = getappdata(root, 'print_overruns');
|
|
if isempty(print_overruns)
|
|
error('Failed to access app data: print_overruns');
|
|
end
|
|
end
|
|
|
|
% Set the state of the 'Print Overruns' flag
|
|
function set_print_overruns(hObject, value)
|
|
root = get_root_object(hObject);
|
|
setappdata(root, 'print_overruns', value);
|
|
end
|
|
|
|
% Get the number of samples that are retrieved from the device per RX
|
|
function [num_samples] = get_num_samples(hObject)
|
|
root = get_root_object(hObject);
|
|
num_samples = getappdata(root, 'num_samples');
|
|
if isempty(num_samples)
|
|
error('Failed to access app data: num_samples');
|
|
end
|
|
end
|
|
|
|
% Get the array of plots
|
|
function [plots] = get_plots(hObject)
|
|
root = get_root_object(hObject);
|
|
plots = getappdata(root, 'plots');
|
|
if isempty(plots)
|
|
error('Failed to access app data: plot');
|
|
end
|
|
end
|
|
|
|
% Apply updates to plot configuration
|
|
function set_plots(hObject, plots)
|
|
root = get_root_object(hObject);
|
|
setappdata(root, 'plots', plots);
|
|
end
|
|
|
|
% Get the frame rate configuration
|
|
function [fps] = get_framerate(hObject)
|
|
root = get_root_object(hObject);
|
|
fps = getappdata(root, 'framerate');
|
|
end
|
|
|
|
% Set the fraem rate configuration
|
|
function set_framerate(hObject, fps)
|
|
root = get_root_object(hObject);
|
|
setappdata(root, 'framerate', fps);
|
|
end
|
|
|
|
function update_plot_axes(hObject, handles)
|
|
plots = get_plots(hObject);
|
|
|
|
Fc = handles.bladerf.rx.frequency;
|
|
Fs = handles.bladerf.rx.samplerate;
|
|
num_samples = get_num_samples(hObject);
|
|
|
|
% Update the axes limits of all plots
|
|
for id = 1:length(plots)
|
|
switch plots{id}.name
|
|
case 'FFT (dB)'
|
|
plots{id}.xmin = (Fc - Fs/2);
|
|
plots{id}.xmax = (Fc + Fs/2);
|
|
plots{id}.ymin = -110;
|
|
plots{id}.ymax = 0;
|
|
|
|
% Ensure the X values are updated, as these are not updated every read
|
|
if id == handles.displaytype.Value
|
|
x = linspace(double(plots{id}.xmin), double(plots{id}.xmax), num_samples);
|
|
plots{id}.lines(1).XData = x;
|
|
end
|
|
|
|
case 'FFT (linear)'
|
|
plots{id}.xmin = (Fc - Fs/2);
|
|
plots{id}.xmax = (Fc + Fs/2);
|
|
plots{id}.ymin = 0;
|
|
plots{id}.ymax = 1;
|
|
|
|
% Ensure the X values are updated, as these are not updated every read
|
|
if id == handles.displaytype.Value
|
|
x = linspace(double(plots{id}.xmin), double(plots{id}.xmax), num_samples);
|
|
plots{id}.lines(1).XData = x;
|
|
end
|
|
|
|
case 'Time (2-Channel)'
|
|
plots{id}.xmin = 0;
|
|
plots{id}.xmax = (num_samples - 1) / Fs;
|
|
plots{id}.ymin = -1.2;
|
|
plots{id}.ymax = 1.2;
|
|
|
|
case 'Time (XY)'
|
|
plots{id}.xmin = -1.2;
|
|
plots{id}.xmax = 1.2;
|
|
plots{id}.ymin = -1.2;
|
|
plots{id}.ymax = 1.2;
|
|
|
|
otherwise
|
|
error('Invalid plot type encountered');
|
|
end
|
|
|
|
% Update the current plot axes
|
|
if id == handles.displaytype.Value
|
|
handles.axes1.XLim = [plots{id}.xmin plots{id}.xmax];
|
|
handles.axes1.YLim = [plots{id}.ymin plots{id}.ymax];
|
|
end
|
|
end
|
|
|
|
set_plots(hObject, plots);
|
|
end
|
|
|
|
function [plot_info] = init_plot_type(hObject, handles, type)
|
|
|
|
plot_info.name = type;
|
|
|
|
blue = [0 0 1];
|
|
red = [1 0 0];
|
|
|
|
num_samples = get_num_samples(hObject);
|
|
|
|
x = zeros(num_samples, 1);
|
|
y = zeros(num_samples, 1);
|
|
|
|
switch type
|
|
case { 'FFT (dB)', 'FFT (linear)' }
|
|
plot_info.xlabel = 'Frequency (MHz)';
|
|
plot_info.ylabel = 'Power (dB)';
|
|
plot_info.lines(1) = line(x, y);
|
|
plot_info.lines(1).Color = blue;
|
|
plot_info.lines(1).Marker = 'none';
|
|
plot_info.lines(1).LineStyle = '-';
|
|
|
|
case 'Time (2-Channel)'
|
|
plot_info.xlabel = 'Time (s)';
|
|
plot_info.ylabel = 'Sample Values (I: Blue, Q: Red)';
|
|
plot_info.lines(1) = line(x, y);
|
|
plot_info.lines(1).Color = blue;
|
|
plot_info.lines(1).Marker = 'none';
|
|
plot_info.lines(1).LineStyle = '-';
|
|
|
|
plot_info.lines(2) = line(x, y);
|
|
plot_info.lines(2).Color = red;
|
|
plot_info.lines(2).Marker = 'none';
|
|
plot_info.lines(2).LineStyle = '-';
|
|
|
|
case 'Time (XY)'
|
|
plot_info.xlabel = 'I Value';
|
|
plot_info.ylabel = 'Q Value';
|
|
plot_info.lines(1) = line(x, y);
|
|
plot_info.lines(1).Color = blue;
|
|
plot_info.lines(1).Marker = '.';
|
|
plot_info.lines(1).LineStyle = 'none';
|
|
plot_info.lines(1).Visible = 'off';
|
|
|
|
otherwise
|
|
error('Invalid plot type encountered');
|
|
end
|
|
end
|
|
|
|
% Update GUI fields with parameter values from device
|
|
function read_device_parameters(hObject, handles)
|
|
|
|
set_agc_selection(handles.agc, handles, handles.bladerf.rx.agc);
|
|
handles.corr_dc_i.String = num2str(handles.bladerf.rx.corrections.dc_i);
|
|
handles.corr_dc_q.String = num2str(handles.bladerf.rx.corrections.dc_q);
|
|
handles.corr_gain.String = num2str(handles.bladerf.rx.corrections.gain);
|
|
handles.corr_phase.String = num2str(handles.bladerf.rx.corrections.phase);
|
|
|
|
handles.frequency.String = addcommas(num2str(handles.bladerf.rx.frequency));
|
|
handles.samplerate.String = addcommas(num2str(handles.bladerf.rx.samplerate));
|
|
set_bandwidth_selection(handles.bandwidth, handles.bladerf.rx.bandwidth);
|
|
|
|
handles.num_buffers.String = num2str(handles.bladerf.rx.config.num_buffers);
|
|
handles.buffer_size.String = num2str(handles.bladerf.rx.config.buffer_size);
|
|
handles.num_transfers.String = num2str(handles.bladerf.rx.config.num_transfers);
|
|
handles.frequency.TooltipString = sprintf('Configures RX frequency. Valid values are %u MHz to %u GHz', ...
|
|
handles.bladerf.rx.min_frequency/1e6, handles.bladerf.rx.max_frequency/1e9);
|
|
|
|
handles.samplerate.TooltipString = sprintf('Configures the RX sample rate. Suggested valuse are [%.2f, %.2f] MHz.', ...
|
|
handles.bladerf.rx.min_sampling/1e6, handles.bladerf.rx.max_sampling/1e6);
|
|
|
|
guidata(hObject, handles);
|
|
end
|
|
|
|
function bladeRF_fft_OpeningFcn(hObject, ~, handles, varargin)
|
|
% Choose default command line output for bladeRF_fft
|
|
handles.output = hObject;
|
|
|
|
% UIWAIT makes bladeRF_fft wait for user response (see UIRESUME)
|
|
% uiwait(handles.figure1);
|
|
handles.bladerf = bladeRF('*:instance=0');
|
|
|
|
read_device_parameters(hObject, handles);
|
|
|
|
handles.bladerf.rx.config.num_buffers = 64;
|
|
handles.bladerf.rx.config.buffer_size = 16384;
|
|
handles.bladerf.rx.config.timeout_ms = 5000;
|
|
|
|
handles.print_overruns.Value = 0;
|
|
setappdata(hObject.Parent, 'print_overruns', 0);
|
|
|
|
setappdata(hObject.Parent, 'run', 0);
|
|
|
|
% Number of samples we'll read from the device at each iteraion
|
|
setappdata(hObject.Parent, 'num_samples', 4096);
|
|
|
|
% Default frame rate
|
|
setappdata(hObject.Parent, 'framerate', 15);
|
|
handles.framerate.String = '15';
|
|
|
|
% Create plot information for each type of lot
|
|
type_strs = handles.displaytype.String;
|
|
|
|
plots = cell(1, length(type_strs));
|
|
for n = 1:length(plots)
|
|
plots{n} = init_plot_type(hObject.Parent, handles, type_strs{n});
|
|
end
|
|
|
|
setappdata(hObject.Parent, 'plots', plots);
|
|
|
|
update_plot_axes(hObject, handles);
|
|
update_plot_selection(hObject.Parent, handles);
|
|
|
|
% Update handles structure
|
|
guidata(hObject, handles);
|
|
end
|
|
|
|
function varargout = bladeRF_fft_OutputFcn(~, ~, handles)
|
|
varargout{1} = handles.output;
|
|
end
|
|
|
|
function displaytype_Callback(hObject, ~, handles)
|
|
update_plot_selection(hObject.Parent.Parent, handles);
|
|
end
|
|
|
|
function displaytype_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function actionbutton_Callback(hObject, ~, handles)
|
|
action = hObject.String;
|
|
switch action
|
|
case 'Start'
|
|
handles.buffer_size.Enable = 'off';
|
|
handles.num_buffers.Enable = 'off';
|
|
handles.num_transfers.Enable = 'off';
|
|
handles.devicelist.Enable = 'off';
|
|
handles.xb200_attached.Enable = 'off';
|
|
|
|
if handles.bladerf.info.gen == 2
|
|
if handles.channel.Value == 1
|
|
handles.bladerf.rx.channel = 'RX1';
|
|
elseif handles.channel.Value == 2
|
|
handles.bladerf.rx.channel = 'RX2';
|
|
end
|
|
else
|
|
handles.bladerf.rx.channel = 'RX1';
|
|
handles.channel.Value = 1;
|
|
end
|
|
handles.channel.Enable = 'off';
|
|
|
|
handles.bladerf.rx.config.num_buffers = str2num(handles.num_buffers.String);
|
|
handles.bladerf.rx.config.buffer_size = str2num(handles.buffer_size.String);
|
|
handles.bladerf.rx.config.num_transfers = str2num(handles.num_transfers.String);
|
|
|
|
hObject.String = 'Stop';
|
|
handles.bladerf.rx.start;
|
|
guidata(hObject, handles);
|
|
|
|
start = cputime;
|
|
update = 1;
|
|
framerate = get_framerate(hObject);
|
|
|
|
num_samples = get_num_samples(hObject);
|
|
|
|
% We'll window our samples. However, we want to normalize
|
|
% this to account for some of its inherent loss.
|
|
if license('test', 'Signal_Toolbox')
|
|
win = blackmanharris(num_samples);
|
|
else
|
|
win = ones(num_samples,1);
|
|
end
|
|
win_norm = (1 / sum(abs(win) ./ num_samples) .* win);
|
|
win_norm = win_norm ./ 4096;
|
|
|
|
plots = get_plots(hObject);
|
|
|
|
samples = zeros(num_samples, 1);
|
|
fft_data = zeros(num_samples, 1);
|
|
history = zeros(num_samples, 1);
|
|
|
|
prev_plot_id = -1;
|
|
|
|
alpha = str2num(handles.fft_avg_alpha.String);
|
|
if isempty(alpha) || alpha < 0.0 || alpha >= 1.0
|
|
alpha = 0.0;
|
|
end
|
|
|
|
run = 1;
|
|
runidx = 0;
|
|
setappdata(hObject.Parent.Parent, 'run', 1);
|
|
|
|
while run == 1
|
|
|
|
[samples(:), ~, ~, overrun] = ...
|
|
handles.bladerf.receive(num_samples);
|
|
|
|
if mod(runidx, 1000) == 0
|
|
handles.gain1.String = handles.bladerf.rx.gain;
|
|
if handles.bladerf.info.gen == 2
|
|
handles.power.Visible = 'on';
|
|
handles.power.String = sprintf('Power Source: %s Consumption: %2.2f W Temperature: %2.2f ''C', ...
|
|
handles.bladerf.misc.dc_source, handles.bladerf.misc.dc_power, handles.bladerf.misc.temperature);
|
|
end
|
|
end
|
|
runidx = runidx + 1;
|
|
|
|
if overrun
|
|
print_overrun = get_print_overruns(hObject);
|
|
if print_overrun ~= 0
|
|
fprintf('Overrun @ t=%f\n', cputime - start);
|
|
end
|
|
elseif update
|
|
update = 0;
|
|
id = handles.displaytype.Value;
|
|
|
|
% Since we're only displaying the GUI at some frame
|
|
% rate, there's no sense in constantly polling the
|
|
% user-supplied alpha for changes.
|
|
new_alpha = str2num(handles.fft_avg_alpha.String);
|
|
if ~isempty(alpha)
|
|
alpha = new_alpha;
|
|
end
|
|
|
|
% If we've changed plot types, we need to reset the
|
|
% FFT history, as it's only relevent for the associated
|
|
% mode
|
|
if id ~= prev_plot_id
|
|
history(:) = zeros(1, length(history)) + plots{id}.ymin;
|
|
end
|
|
|
|
switch plots{id}.name
|
|
case 'FFT (dB)'
|
|
fft_data(:) = 20*log10(abs(fftshift(fft(samples .* win_norm))));
|
|
history(:) = history .* alpha + (1 - alpha) .* fft_data;
|
|
plots{id}.lines(1).YData(:) = history;
|
|
|
|
case 'FFT (linear)'
|
|
fft_data = abs(fftshift(fft(samples .* win_norm)));
|
|
history(:) = history .* alpha + (1 - alpha) .* fft_data;
|
|
plots{id}.lines(1).YData(:) = history;
|
|
|
|
case 'Time (2-Channel)'
|
|
plots{id}.lines(1).YData(:) = real(samples);
|
|
plots{id}.lines(2).YData(:) = imag(samples);
|
|
|
|
case 'Time (XY)'
|
|
plots{id}.lines(1).XData(:) = real(samples);
|
|
plots{id}.lines(1).YData(:) = imag(samples);
|
|
|
|
otherwise
|
|
error('Invalid plot selection encountered');
|
|
end
|
|
|
|
drawnow;
|
|
tic;
|
|
|
|
prev_plot_id = id;
|
|
framerate = get_framerate(hObject);
|
|
else
|
|
t = toc;
|
|
update = (t > (1/framerate));
|
|
end
|
|
|
|
run = getappdata(hObject.Parent.Parent, 'run');
|
|
end
|
|
|
|
handles.bladerf.rx.stop;
|
|
figHandle = getappdata(hObject.Parent.Parent, 'ready_to_delete');
|
|
if ~isempty(figHandle)
|
|
delete(figHandle);
|
|
end
|
|
|
|
case 'Stop'
|
|
setappdata(hObject.Parent.Parent, 'run', 0);
|
|
handles.buffer_size.Enable = 'on';
|
|
handles.num_buffers.Enable = 'on';
|
|
handles.num_transfers.Enable = 'on';
|
|
handles.devicelist.Enable = 'on';
|
|
handles.xb200_attached.Enable = 'on';
|
|
handles.channel.Enable = 'on';
|
|
|
|
hObject.String = 'Start';
|
|
guidata(hObject, handles);
|
|
|
|
otherwise
|
|
error(strcat('Unexpected button action: ', action))
|
|
end
|
|
end
|
|
|
|
function agc_Callback(hObject, ~, handles)
|
|
items = hObject.String;
|
|
index = hObject.Value;
|
|
|
|
%fprintf('GUI Request to set LNA gain to: %s\n', items{index})
|
|
|
|
handles.bladerf.rx.agc = items{index};
|
|
|
|
set_agc_selection(hObject, handles, handles.bladerf.rx.agc);
|
|
%i = cellfun(@(x)strcmpi(x,handles.bladerf.rx.agc),hObject.String);
|
|
%hObject.Value = find(i);
|
|
guidata(hObject, handles);
|
|
end
|
|
|
|
function agc_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = white;
|
|
end
|
|
end
|
|
|
|
function gain1_Callback(hObject, ~, handles)
|
|
val = str2num(hObject.String);
|
|
if isempty(val)
|
|
val = handles.bladerf.rx.vga1;
|
|
end
|
|
|
|
%val = min(30, val);
|
|
%val = max(5, val);
|
|
|
|
%fprintf('GUI request to set Gain1: %d\n', val);
|
|
|
|
handles.bladerf.rx.gain = val;
|
|
hObject.String = num2str(handles.bladerf.rx.gain);
|
|
guidata(hObject, handles);
|
|
end
|
|
|
|
function gain1_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function bandwidth_Callback(hObject, ~, handles)
|
|
values = hObject.String;
|
|
index = hObject.Value;
|
|
selected = str2num(values{index});
|
|
|
|
bw = selected * 1.0e6;
|
|
%fprintf('GUI request to set bandwidth to: %f\n', bw);
|
|
|
|
handles.bladerf.rx.bandwidth = bw;
|
|
end
|
|
|
|
function bandwidth_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function channel_Callback(hObject, ~, handles)
|
|
values = hObject.String;
|
|
index = hObject.Value;
|
|
if handles.bladerf.info.gen == 2 && strcmpi(values{index}, 'RX2')
|
|
handles.bladerf.rx.channel = 'RX2';
|
|
else
|
|
handles.bladerf.rx.channel = 'RX1';
|
|
hObject.Value = 1;
|
|
end
|
|
end
|
|
|
|
function channel_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function corr_dc_i_Callback(hObject, ~, handles)
|
|
val = str2num(hObject.String);
|
|
if isempty(val)
|
|
val = handles.bladerf.rx.corrections.dc_i;
|
|
end
|
|
|
|
val = min(2048, val);
|
|
val = max(-2048, val);
|
|
|
|
%fprintf('GUI request to set I DC correction to: %f\n', val)
|
|
handles.bladerf.rx.corrections.dc_i = val;
|
|
|
|
hObject.String = num2str(val);
|
|
end
|
|
|
|
function corr_dc_i_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function corr_dc_q_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function corr_dc_q_Callback(hObject, ~, handles)
|
|
val = str2num(hObject.String);
|
|
if isempty(val)
|
|
val = handles.bladerf.rx.corrections.dc_q;
|
|
end
|
|
|
|
val = min(2048, val);
|
|
val = max(-2048, val);
|
|
|
|
%fprintf('GUI request to set IQ DC correction to: %f\n', val)
|
|
handles.bladerf.rx.corrections.dc_q = val;
|
|
|
|
hObject.String = num2str(val);
|
|
end
|
|
|
|
function corr_gain_Callback(hObject, ~, handles)
|
|
val = str2num(hObject.String);
|
|
if isempty(val)
|
|
val = handles.bladerf.rx.corrections.gain;
|
|
end
|
|
|
|
val = max(-1.0, val);
|
|
val = min(1.0, val);
|
|
|
|
%fprintf('GUI request to set IQ gain correction to: %f\n', val)
|
|
handles.bladerf.rx.corrections.gain = val;
|
|
|
|
hObject.String = num2str(val);
|
|
end
|
|
|
|
|
|
function corr_gain_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function corr_phase_Callback(hObject, ~, handles)
|
|
val = str2num(hObject.String);
|
|
if isempty(val)
|
|
val = handles.bladerf.rx.corrections.phase;
|
|
end
|
|
|
|
%fprintf('GUI request to set phase correction to: %f\n', val)
|
|
handles.bladerf.rx.corrections.phase = val;
|
|
|
|
val = handles.bladerf.rx.corrections.phase;
|
|
hObject.String = num2str(val);
|
|
end
|
|
|
|
function corr_phase_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function samplerate_Callback(hObject, ~, handles)
|
|
val = str2num(removecommas(hObject.String));
|
|
if isempty(val)
|
|
val = handles.bladerf.rx.samplerate;
|
|
end
|
|
|
|
val = min(handles.bladerf.rx.max_sampling, val);
|
|
val = max(handles.bladerf.rx.min_sampling, val);
|
|
|
|
%fprintf('GUI request to set samplerate to: %f\n', val);
|
|
|
|
handles.bladerf.rx.samplerate = val;
|
|
val = handles.bladerf.rx.samplerate;
|
|
hObject.String = addcommas(num2str(val));
|
|
|
|
update_plot_axes(hObject, handles);
|
|
end
|
|
|
|
function samplerate_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function val = addcommas(strval)
|
|
idxend = strfind(strval, '.');
|
|
if isempty(idxend)
|
|
idxend = size(strval, 2)+1;
|
|
end
|
|
strval(2, idxend - 4: -3 : 1) = ',';
|
|
val = transpose(strval(strval ~= char(0)));
|
|
end
|
|
|
|
function val = removecommas(strval)
|
|
val = regexprep(strval,',','');
|
|
end
|
|
|
|
function frequency_Callback(hObject, ~, handles)
|
|
val = str2num(removecommas(hObject.String));
|
|
if isempty(val)
|
|
val = handles.bladerf.rx.frequency;
|
|
end
|
|
|
|
val = min(handles.bladerf.rx.max_frequency, val);
|
|
val = max(handles.bladerf.rx.min_frequency, val);
|
|
|
|
%fprintf('GUI request to set frequency: %d\n', val);
|
|
|
|
handles.bladerf.rx.frequency = val;
|
|
|
|
hObject.String = addcommas(num2str(val));
|
|
hObject.Value = val;
|
|
|
|
update_plot_axes(hObject, handles);
|
|
end
|
|
|
|
function frequency_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function devicelist_Callback(hObject, ~, handles)
|
|
if handles.xb200_attached.Value == true
|
|
xb = 'XB200';
|
|
else
|
|
xb = [];
|
|
end
|
|
|
|
items = hObject.String;
|
|
index = hObject.Value;
|
|
devstring = items{index};
|
|
handles.bladerf.delete;
|
|
guidata(hObject, handles);
|
|
handles.bladerf = bladeRF(devstring, [], xb);
|
|
read_device_parameters(hObject, handles);
|
|
guidata(hObject, handles);
|
|
end
|
|
|
|
function xb200_attached_Callback(hObject, ~, handles)
|
|
if hObject.Value == true
|
|
xb = 'XB200';
|
|
else
|
|
xb = [];
|
|
end
|
|
|
|
items = handles.devicelist.String;
|
|
index = handles.devicelist.Value;
|
|
devstring = items{index};
|
|
handles.bladerf.delete;
|
|
guidata(hObject, handles);
|
|
handles.bladerf = bladeRF(devstring, [], xb);
|
|
read_device_parameters(hObject, handles);
|
|
guidata(hObject, handles);
|
|
end
|
|
|
|
|
|
function devicelist_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
devs = bladeRF.devices;
|
|
list = cell(1, length(devs));
|
|
for idx=1:length(devs)
|
|
switch devs(idx).backend
|
|
case 'BLADERF_BACKEND_LIBUSB'
|
|
backend = 'libusb';
|
|
case 'BLADERF_BACKEND_CYPRESS'
|
|
backend = 'cypress';
|
|
otherwise
|
|
disp('Not sure which backend is being used');
|
|
backend = '*';
|
|
end
|
|
list{idx} = strcat(backend, ':serial=', devs(idx).serial);
|
|
end
|
|
hObject.String = list;
|
|
end
|
|
|
|
function figure1_CloseRequestFcn(hObject, ~, ~)
|
|
running = getappdata(hObject.Parent, 'run');
|
|
if running == 1
|
|
% Our hackish receive loop is still running. Flag it to shut
|
|
% down and have it take care of the final delete().
|
|
setappdata(hObject.Parent, 'run', 0);
|
|
setappdata(hObject.Parent, 'ready_to_delete', hObject)
|
|
else
|
|
% We can shut down now.
|
|
delete(hObject);
|
|
end
|
|
end
|
|
|
|
function num_buffers_Callback(hObject, ~, handles)
|
|
num_buffers = str2num(hObject.String);
|
|
if isempty(num_buffers)
|
|
num_buffers = handles.bladerf.rx.config.num_buffers;
|
|
end
|
|
|
|
num_buffers = max(2, num_buffers);
|
|
handles.bladerf.rx.config.num_buffers = num_buffers;
|
|
hObject.String = num2str(num_buffers);
|
|
end
|
|
|
|
function num_buffers_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function buffer_size_Callback(hObject, ~, handles)
|
|
buffer_size = str2num(hObject.String);
|
|
if isempty(buffer_size);
|
|
buffer_size = handles.bladerf.rx.config.buffer_size;
|
|
end
|
|
|
|
if (mod(buffer_size, 1024) ~= 0)
|
|
buffer_size = max(1024, floor((buffer_size / 1024)) * 1024);
|
|
end
|
|
|
|
handles.bladerf.rx.config.buffer_size = buffer_size;
|
|
hObject.String = num2str(handles.bladerf.rx.config.buffer_size);
|
|
end
|
|
|
|
function buffer_size_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function num_transfers_Callback(hObject, ~, handles)
|
|
num_transfers = str2num(hObject.String);
|
|
if isempty(num_transfers)
|
|
num_transfers = handles.bladerf.rx.config.num_transfers;
|
|
end
|
|
|
|
num_buffers = handles.bladerf.rx.config.num_buffers;
|
|
|
|
if num_transfers < 1
|
|
num_transfers = 1;
|
|
elseif num_transfers > floor(num_buffers / 2)
|
|
num_transfers = max(1, floor(num_buffers/2));
|
|
end
|
|
|
|
handles.bladerf.rx.config.num_transfers = num_transfers;
|
|
hObject.String = num2str(handles.bladerf.rx.config.num_transfers);
|
|
end
|
|
|
|
function num_transfers_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function enable_biastee_Callback(hObject, ~, handles)
|
|
if hObject.Value ~= 0
|
|
set_enable_biastee(handles, hObject, 1);
|
|
else
|
|
set_enable_biastee(handles, hObject, 0);
|
|
end
|
|
end
|
|
|
|
function print_overruns_Callback(hObject, ~, ~)
|
|
if hObject.Value ~= 0
|
|
set_print_overruns(hObject, 1);
|
|
else
|
|
set_print_overruns(hObject, 0);
|
|
end
|
|
end
|
|
|
|
function fft_avg_alpha_Callback(~, ~, ~)
|
|
end
|
|
|
|
function fft_avg_alpha_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
hObject.BackgroundColor = 'white';
|
|
end
|
|
end
|
|
|
|
function framerate_Callback(hObject, ~, ~)
|
|
fps = str2num(hObject.String);
|
|
if isempty(fps) == true
|
|
fps = get_framerate(hObject);
|
|
elseif fps < 1
|
|
fps = 1;
|
|
end
|
|
|
|
fps = round(fps);
|
|
hObject.String = num2str(fps);
|
|
set_framerate(hObject, fps);
|
|
end
|
|
|
|
function framerate_CreateFcn(hObject, ~, ~)
|
|
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
|
|
set(hObject,'BackgroundColor','white');
|
|
end
|
|
end
|