Add files via upload
Jon Kraft
GitHub
parent
0c588367bc
commit
2a91b071cf
|
|
@ -0,0 +1,53 @@
|
||||||
|
classdef AnalogAmplitudeCalibrationFormat
|
||||||
|
|
||||||
|
properties
|
||||||
|
CourseSubarray1Data
|
||||||
|
CourseSubarray2Data
|
||||||
|
FineSubarray1Data
|
||||||
|
FineSubarray2Data
|
||||||
|
end
|
||||||
|
|
||||||
|
methods
|
||||||
|
function s = toStruct(this)
|
||||||
|
s.CourseSubarray1Data = this.CourseSubarray1Data;
|
||||||
|
s.CourseSubarray2Data = this.CourseSubarray2Data;
|
||||||
|
s.FineSubarray1Data = this.FineSubarray1Data;
|
||||||
|
s.FineSubarray2Data = this.FineSubarray2Data;
|
||||||
|
end
|
||||||
|
|
||||||
|
function [cal1,cal2] = getCourseCalValues(this)
|
||||||
|
cal1 = this.getCourseCal1();
|
||||||
|
cal2 = this.getCourseCal2();
|
||||||
|
end
|
||||||
|
|
||||||
|
function [cal1,cal2] = getFineCalValues(this)
|
||||||
|
cal1 = this.getFineCal1();
|
||||||
|
cal2 = this.getFineCal2();
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
methods (Access = private)
|
||||||
|
function cal1 = getCourseCal1(this)
|
||||||
|
cal1 = this.getCal(this.CourseSubarray1Data);
|
||||||
|
end
|
||||||
|
|
||||||
|
function cal1 = getFineCal1(this)
|
||||||
|
cal1 = this.getCal(this.FineSubarray1Data);
|
||||||
|
end
|
||||||
|
|
||||||
|
function cal2 = getCourseCal2(this)
|
||||||
|
cal2 = this.getCal(this.CourseSubarray2Data);
|
||||||
|
end
|
||||||
|
|
||||||
|
function cal2 = getFineCal2(this)
|
||||||
|
cal2 = this.getCal(this.FineSubarray2Data);
|
||||||
|
end
|
||||||
|
|
||||||
|
function cal = getCal(~,data)
|
||||||
|
% get amplitudes
|
||||||
|
amp = mean(max(abs(fft(data))));
|
||||||
|
scaling = min(amp) ./ amp;
|
||||||
|
cal = reshape(scaling,[1 4]);
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,45 @@
|
||||||
|
classdef AnalogPhaseCalibrationFormat
|
||||||
|
|
||||||
|
properties
|
||||||
|
PhaseSetting
|
||||||
|
Subarray1Measurements
|
||||||
|
Subarray2Measurements
|
||||||
|
end
|
||||||
|
|
||||||
|
methods
|
||||||
|
function s = toStruct(this)
|
||||||
|
s.PhaseSetting = this.PhaseSetting;
|
||||||
|
s.Subarray1Measurements = this.Subarray1Measurements;
|
||||||
|
s.Subarray2Measurements = this.Subarray2Measurements;
|
||||||
|
end
|
||||||
|
|
||||||
|
function [cal1,cal2] = getCalValues(this)
|
||||||
|
cal1 = this.sub1Cal();
|
||||||
|
cal2 = this.sub2Cal();
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
methods (Access = private)
|
||||||
|
function cal1 = sub1Cal(this)
|
||||||
|
cal1 = this.subCal(this.Subarray1Measurements);
|
||||||
|
end
|
||||||
|
|
||||||
|
function cal2 = sub2Cal(this)
|
||||||
|
cal2 = this.subCal(this.Subarray2Measurements);
|
||||||
|
end
|
||||||
|
|
||||||
|
function cal = subCal(this,data)
|
||||||
|
% Get signal amplitude
|
||||||
|
datafft = abs(fft(data));
|
||||||
|
amp = max(datafft,[],1);
|
||||||
|
|
||||||
|
% Get location of min amplitude
|
||||||
|
[~,phaseIdx] = min(amp,[],2);
|
||||||
|
|
||||||
|
% Get calibration phase
|
||||||
|
calPhase = wrapTo360(this.PhaseSetting(phaseIdx)-180);
|
||||||
|
cal = [0;calPhase.'];
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
@ -0,0 +1,167 @@
|
||||||
|
classdef AntennaInteractor < handle
|
||||||
|
|
||||||
|
properties
|
||||||
|
ArrayControl
|
||||||
|
PlutoControl
|
||||||
|
Model
|
||||||
|
Fc
|
||||||
|
SubSteer
|
||||||
|
ArraySteer
|
||||||
|
LastPhase
|
||||||
|
LastGain
|
||||||
|
AnalogWeights
|
||||||
|
DigitalWeights
|
||||||
|
end
|
||||||
|
|
||||||
|
methods
|
||||||
|
function this = AntennaInteractor(fc,calValues)
|
||||||
|
[rx,bf,model] = setupAntenna(fc);
|
||||||
|
this.ArrayControl = bf;
|
||||||
|
this.PlutoControl = rx;
|
||||||
|
this.Model = model;
|
||||||
|
this.Fc = fc;
|
||||||
|
this.SubSteer = phased.SteeringVector("SensorArray",this.Model.Subarray,'NumPhaseShifterBits',7);
|
||||||
|
this.ArraySteer = phased.SteeringVector("SensorArray",this.Model);
|
||||||
|
this.AnalogWeights = calValues.AnalogWeights;
|
||||||
|
this.DigitalWeights = calValues.DigitalWeights;
|
||||||
|
end
|
||||||
|
|
||||||
|
function updateCalibration(this,calValues)
|
||||||
|
this.updateAnalogWeights(calValues.AnalogWeights);
|
||||||
|
this.updateDigitalWeights(calValues.DigitalWeights);
|
||||||
|
end
|
||||||
|
|
||||||
|
function updateAnalogWeights(this,analogWeights)
|
||||||
|
this.AnalogWeights = analogWeights;
|
||||||
|
end
|
||||||
|
|
||||||
|
function updateDigitalWeights(this,digitalWeights)
|
||||||
|
this.DigitalWeights = digitalWeights;
|
||||||
|
end
|
||||||
|
|
||||||
|
function [patternData,rxdata] = capturePattern(this,steerangles)
|
||||||
|
patternData = zeros(1024,numel(steerangles));
|
||||||
|
for ii = 1 : numel(steerangles)
|
||||||
|
[analogweights,digitalweights] = this.getAllWeights(steerangles(ii));
|
||||||
|
rxdata = this.steerAnalog(analogweights);
|
||||||
|
patternData(:,ii) = rxdata * conj(digitalweights);
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
function [sumdiffampdelta,sumdiffphasedelta,sumpatterndata,diffpatternData] = captureMonopulsePattern(this,steerangles)
|
||||||
|
sumpatterndata = zeros(1024,numel(steerangles));
|
||||||
|
diffpatternData = zeros(1024,numel(steerangles));
|
||||||
|
for ii = 1 : numel(steerangles)
|
||||||
|
% capture data
|
||||||
|
[analogweights,digitalweights] = this.getAllWeights(steerangles(ii));
|
||||||
|
rxdata = this.steerAnalog(analogweights);
|
||||||
|
|
||||||
|
% sum
|
||||||
|
sumpatterndata(:,ii) = rxdata * conj(digitalweights);
|
||||||
|
|
||||||
|
% diff
|
||||||
|
diffdigitalweights = digitalweights .* [1;-1];
|
||||||
|
diffpatternData(:,ii) = rxdata * conj(diffdigitalweights);
|
||||||
|
end
|
||||||
|
|
||||||
|
% calulate sum and diff amplitude and phase deltas
|
||||||
|
sumamp = mag2db(helperGetAmplitude(sumpatterndata));
|
||||||
|
diffamp = mag2db(helperGetAmplitude(diffpatternData));
|
||||||
|
sumdiffampdelta = sumamp-diffamp;
|
||||||
|
|
||||||
|
sumphase = helperGetPhase(sumpatterndata);
|
||||||
|
diffphase = helperGetPhase(diffpatternData);
|
||||||
|
sumdiffphasedelta = sign(wrapTo180(sumphase-diffphase));
|
||||||
|
end
|
||||||
|
|
||||||
|
function patternData = capturePatternWithNull(this,steerangles,nullangle)
|
||||||
|
patternData = zeros(1024,numel(steerangles));
|
||||||
|
for ii = 1 : numel(steerangles)
|
||||||
|
[analogweights,digitalweights] = this.getAllWeightsNull(steerangles(ii),nullangle);
|
||||||
|
rxdata = this.steerAnalog(analogweights);
|
||||||
|
patternData(:,ii) = rxdata * conj(digitalweights);
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
function rxdata = steerAnalog(this,analogWeights)
|
||||||
|
% Set analog phase shifter
|
||||||
|
phases = this.getPhaseCodes(analogWeights);
|
||||||
|
if ~isequal(this.LastPhase,phases)
|
||||||
|
this.ArrayControl.RxPhase(:) = phases;
|
||||||
|
this.LastPhase = phases;
|
||||||
|
end
|
||||||
|
|
||||||
|
% Set analog gain
|
||||||
|
gainCode = this.getGainCodes(analogWeights);
|
||||||
|
if ~isequal(this.LastGain,gainCode)
|
||||||
|
this.ArrayControl.RxGain(:) = gainCode;
|
||||||
|
this.LastGain = gainCode;
|
||||||
|
end
|
||||||
|
|
||||||
|
% receive data
|
||||||
|
this.ArrayControl.LatchRxSettings();
|
||||||
|
this.PlutoControl();
|
||||||
|
rxdata = this.PlutoControl();
|
||||||
|
end
|
||||||
|
|
||||||
|
function phases = getPhaseCodes(this,analogWeights)
|
||||||
|
sub1weights = analogWeights(:,1);
|
||||||
|
sub2weights = analogWeights(:,2);
|
||||||
|
sub1phase = this.getPhase(sub1weights);
|
||||||
|
sub2phase = this.getPhase(sub2weights);
|
||||||
|
phases = [sub1phase',sub2phase'];
|
||||||
|
phases = phases - phases(1);
|
||||||
|
phases = wrapTo360(phases);
|
||||||
|
end
|
||||||
|
|
||||||
|
function codes = getGainCodes(~,analogWeights)
|
||||||
|
codes = helperGainCodes(analogWeights);
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
methods (Access = private)
|
||||||
|
function [analogweights,digitalweights] = getAllWeights(this,steerangle)
|
||||||
|
defaultAnalogWeights = this.AnalogWeights;
|
||||||
|
defaultDigitalWeights = this.DigitalWeights;
|
||||||
|
|
||||||
|
% get analog weights
|
||||||
|
analogweights = this.getWeights(steerangle,defaultAnalogWeights,this.SubSteer);
|
||||||
|
|
||||||
|
% get digital weights, flip to ensure they are being applied to
|
||||||
|
% the correct channel.
|
||||||
|
flippedDigitalWeights = [defaultDigitalWeights(2);defaultDigitalWeights(1)];
|
||||||
|
digitalweights = this.getWeights(steerangle,flippedDigitalWeights,this.ArraySteer);
|
||||||
|
digitalweights = [digitalweights(2);digitalweights(1)];
|
||||||
|
end
|
||||||
|
|
||||||
|
function [analogweights,digitalweights] = getAllWeightsNull(this,steerangle,nullangle)
|
||||||
|
defaultAnalogWeights = this.AnalogWeights;
|
||||||
|
defaultDigitalWeights = this.DigitalWeights;
|
||||||
|
|
||||||
|
% get analogweights
|
||||||
|
analogweights = this.getWeightsNull(steerangle,nullangle,defaultAnalogWeights,this.SubSteer);
|
||||||
|
|
||||||
|
% get digital weights
|
||||||
|
flippedDigitalWeights = [defaultDigitalWeights(2);defaultDigitalWeights(1)];
|
||||||
|
digitalweights = this.getWeightsNull(steerangle,nullangle,flippedDigitalWeights,this.ArraySteer);
|
||||||
|
digitalweights = [digitalweights(2);digitalweights(1)];
|
||||||
|
end
|
||||||
|
|
||||||
|
function weights = getWeights(this,steerangle,defaultweights,sv)
|
||||||
|
initialweights = sv(this.Fc,steerangle);
|
||||||
|
weights = initialweights .* defaultweights;
|
||||||
|
end
|
||||||
|
|
||||||
|
function weights = getWeightsNull(this,steerangle,nullangle,defaultweights,sv)
|
||||||
|
steerweight = sv(this.Fc,steerangle);
|
||||||
|
nullweight = sv(this.Fc,nullangle);
|
||||||
|
rn = nullweight'*steerweight/(nullweight'*nullweight);
|
||||||
|
steernullweight = steerweight-nullweight*rn;
|
||||||
|
weights = steernullweight .* defaultweights;
|
||||||
|
end
|
||||||
|
|
||||||
|
function phase = getPhase(~,weights)
|
||||||
|
phase = rad2deg(angle(weights));
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,27 @@
|
||||||
|
classdef ArrayFactorDataFormat
|
||||||
|
|
||||||
|
% Carry array factor data for calibration example
|
||||||
|
|
||||||
|
properties
|
||||||
|
SteeringAngle
|
||||||
|
UncalibratedPattern
|
||||||
|
AnalogCourseAmplitudeCalPattern
|
||||||
|
AnalogPhaseCalPattern
|
||||||
|
AnalogFineAmplitudeCalPattern
|
||||||
|
DigitalAmplitudeCalPattern
|
||||||
|
FullCalibration
|
||||||
|
end
|
||||||
|
|
||||||
|
methods
|
||||||
|
function s = toStruct(this)
|
||||||
|
s.SteeringAngle = this.SteeringAngle;
|
||||||
|
s.UncalibratedPattern = this.UncalibratedPattern;
|
||||||
|
s.AnalogCourseAmplitudeCalPattern = this.AnalogCourseAmplitudeCalPattern;
|
||||||
|
s.AnalogPhaseCalPattern = this.AnalogPhaseCalPattern;
|
||||||
|
s.AnalogFineAmplitudeCalPattern = this.AnalogFineAmplitudeCalPattern;
|
||||||
|
s.DigitalAmplitudeCalPattern = this.DigitalAmplitudeCalPattern;
|
||||||
|
s.FullCalibration = this.FullCalibration;
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
@ -0,0 +1,25 @@
|
||||||
|
classdef CalibrationDataFormat
|
||||||
|
|
||||||
|
% Store calibration data
|
||||||
|
|
||||||
|
properties
|
||||||
|
ExampleData
|
||||||
|
CalibrationWeights = CalibrationWeightFormat();
|
||||||
|
AntennaPattern = ArrayFactorDataFormat();
|
||||||
|
AnalogPhaseCalibration = AnalogPhaseCalibrationFormat();
|
||||||
|
AnalogAmplitudeCalibration = AnalogAmplitudeCalibrationFormat();
|
||||||
|
DigitalCalibration = DigitalCalibrationFormat();
|
||||||
|
end
|
||||||
|
|
||||||
|
methods
|
||||||
|
function s = toStruct(this)
|
||||||
|
s.ExampleData = this.ExampleData;
|
||||||
|
s.CalibrationValues = this.CalibrationWeights.toStruct();
|
||||||
|
s.AntennaPattern = this.AntennaPattern.toStruct();
|
||||||
|
s.AnalogPhaseCalibration = this.AnalogPhaseCalibration.toStruct();
|
||||||
|
s.AnalogAmplitudeCalibration = this.AnalogAmplitudeCalibration.toStruct();
|
||||||
|
s.DigitalCalibration = this.DigitalCalibration.toStruct();
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
@ -0,0 +1,17 @@
|
||||||
|
classdef CalibrationValueFormat
|
||||||
|
|
||||||
|
% Store the antenna calibration values
|
||||||
|
|
||||||
|
properties
|
||||||
|
AnalogWeights
|
||||||
|
DigitalWeights
|
||||||
|
end
|
||||||
|
|
||||||
|
methods
|
||||||
|
function s = toStruct(this)
|
||||||
|
s.AnalogWeights = this.AnalogWeights;
|
||||||
|
s.DigitalWeights = this.DigitalWeights;
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
@ -0,0 +1,25 @@
|
||||||
|
classdef CalibrationWeightFormat
|
||||||
|
|
||||||
|
% Hold calibration weights at each step of the calibration process.
|
||||||
|
|
||||||
|
properties
|
||||||
|
UncalibratedWeights = CalibrationValueFormat()
|
||||||
|
AnalogCourseAmplitudeWeights = CalibrationValueFormat()
|
||||||
|
AnalogPhaseWeights = CalibrationValueFormat()
|
||||||
|
AnalogFineAmplitudeWeights = CalibrationValueFormat()
|
||||||
|
DigitalAmplitudeWeights = CalibrationValueFormat()
|
||||||
|
FinalCalibrationWeights = CalibrationValueFormat()
|
||||||
|
end
|
||||||
|
|
||||||
|
methods
|
||||||
|
function s = toStruct(this)
|
||||||
|
s.UncalibratedWeights = this.UncalibratedWeights.toStruct();
|
||||||
|
s.AnalogCourseAmplitudeWeights = this.AnalogCourseAmplitudeWeights.toStruct();
|
||||||
|
s.AnalogPhaseWeights = this.AnalogPhaseWeights.toStruct();
|
||||||
|
s.AnalogFineAmplitudeWeights = this.AnalogFineAmplitudeWeights.toStruct();
|
||||||
|
s.DigitalAmplitudeWeights = this.DigitalAmplitudeWeights.toStruct();
|
||||||
|
s.FinalCalibrationWeights = this.FinalCalibrationWeights.toStruct();
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
@ -0,0 +1,28 @@
|
||||||
|
classdef DigitalCalibrationFormat
|
||||||
|
|
||||||
|
properties
|
||||||
|
MeasuredData
|
||||||
|
end
|
||||||
|
|
||||||
|
methods
|
||||||
|
function s = toStruct(this)
|
||||||
|
s.AmplitudeCalData = this.MeasuredData;
|
||||||
|
end
|
||||||
|
|
||||||
|
function gain = channelGain(this)
|
||||||
|
fReceive = max(abs(fft(this.MeasuredData)));
|
||||||
|
gain = max(fReceive) ./ fReceive;
|
||||||
|
end
|
||||||
|
|
||||||
|
function channelWeights = getChannelPhaseOffset(this)
|
||||||
|
phase = deg2rad(0:360);
|
||||||
|
st_vec = [ones(size(phase)); exp(1i*phase)];
|
||||||
|
sig = this.MeasuredData*conj(st_vec);
|
||||||
|
sigfft = fft(sig);
|
||||||
|
af = max(abs(sigfft));
|
||||||
|
[~, ind_phase] = max(af);
|
||||||
|
channelWeights = st_vec(:,ind_phase);
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
Binary file not shown.
|
|
@ -0,0 +1,141 @@
|
||||||
|
clear; close all;
|
||||||
|
warning('off','MATLAB:system:ObsoleteSystemObjectMixin');
|
||||||
|
|
||||||
|
% Key Parameters
|
||||||
|
signal_freq = 10.145e9; % this is the HB100 frequency
|
||||||
|
%signal_freq = findTxFrequency();
|
||||||
|
plutoURI = 'ip:192.168.2.1';
|
||||||
|
phaserURI = 'ip:phaser.local';
|
||||||
|
run_calibration = true;
|
||||||
|
use_calibration = true;
|
||||||
|
|
||||||
|
%% Run Calibration
|
||||||
|
if run_calibration == true
|
||||||
|
CalibrationData = calibrationRoutine(signal_freq);
|
||||||
|
finalcalweights = CalibrationData.CalibrationWeights.FinalCalibrationWeights;
|
||||||
|
save("calibration_data.mat", "finalcalweights");
|
||||||
|
else
|
||||||
|
if isfile("calibration_data.mat") == true
|
||||||
|
load("calibration_data.mat", "finalcalweights");
|
||||||
|
else
|
||||||
|
use_calibration = false;
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
%% Load the measured gain profiles
|
||||||
|
load('GainProfile.mat','subArray1_NormalizedGainProfile','subArray2_NormalizedGainProfile','gaincode');
|
||||||
|
|
||||||
|
% Setup the pluto
|
||||||
|
rx = setupPluto(plutoURI);
|
||||||
|
|
||||||
|
% Setup the phaser
|
||||||
|
bf = setupPhaser(rx,phaserURI,signal_freq);
|
||||||
|
bf.RxPowerDown(:) = 0;
|
||||||
|
bf.RxGain(:) = 127;
|
||||||
|
|
||||||
|
% Create the model of the phaser, which consists of 2 4-element subarrays
|
||||||
|
nElements = 4;
|
||||||
|
subarrayModel = phased.ULA('NumElements',nElements,'ElementSpacing',bf.ElementSpacing);
|
||||||
|
nSubarrays = 2;
|
||||||
|
arrayModel = phased.ReplicatedSubarray("Subarray",subarrayModel,"GridSize",[1,nSubarrays],'SubarraySteering','Custom');
|
||||||
|
|
||||||
|
% Create the steering vector for the subarray and the main array
|
||||||
|
subarraySteer = phased.SteeringVector("SensorArray",subarrayModel,'NumPhaseShifterBits',7);
|
||||||
|
arraySteer = phased.SteeringVector("SensorArray",arrayModel);
|
||||||
|
|
||||||
|
% Set the analog and digital calibration weights. To see the uncalibrated
|
||||||
|
% array factor, all weights are set to 1.
|
||||||
|
if use_calibration == true
|
||||||
|
% These will need to be set based on the calibration routine
|
||||||
|
analogWeights = finalcalweights.AnalogWeights;
|
||||||
|
digitalWeights = finalcalweights.DigitalWeights;
|
||||||
|
else
|
||||||
|
% Weights all equal to 1 is an uncalibrated antenna
|
||||||
|
analogWeights = ones(4,2);
|
||||||
|
digitalWeights = ones(2,1);
|
||||||
|
end
|
||||||
|
|
||||||
|
%% Sweep the steering angle and capture data
|
||||||
|
steeringAngle = -90 : 90;
|
||||||
|
ArrayFactor = zeros(size(steeringAngle));
|
||||||
|
for ii = 1 : numel(steeringAngle)
|
||||||
|
currentangle = steeringAngle(ii);
|
||||||
|
|
||||||
|
% Get the steering weights for the subarray elements
|
||||||
|
subarraysteerweights = subarraySteer(signal_freq,currentangle);
|
||||||
|
adjustedsubarrayweights = subarraysteerweights .* analogWeights;
|
||||||
|
|
||||||
|
% Get element phase from steering weights
|
||||||
|
sub1weights = adjustedsubarrayweights(:,1);
|
||||||
|
sub2weights = adjustedsubarrayweights(:,2);
|
||||||
|
sub1phase = rad2deg(angle(sub1weights));
|
||||||
|
sub2phase = rad2deg(angle(sub2weights));
|
||||||
|
phases = [sub1phase',sub2phase'];
|
||||||
|
phases = phases - phases(1);
|
||||||
|
phases = wrapTo360(phases);
|
||||||
|
|
||||||
|
% Get the element gain from steering weights
|
||||||
|
sub1gain = mag2db(abs(sub1weights));
|
||||||
|
sub2gain = mag2db(abs(sub2weights));
|
||||||
|
calibGainCode = zeros(1,8);
|
||||||
|
for nch = 1 : 4
|
||||||
|
% Set gain codes for array 1
|
||||||
|
xp = sub1gain(nch);
|
||||||
|
if xp == -Inf
|
||||||
|
calibGainCode(nch) = 0;
|
||||||
|
else
|
||||||
|
calibGainCode(nch) = round(interp1(subArray1_NormalizedGainProfile(:,nch),gaincode,xp));
|
||||||
|
end
|
||||||
|
|
||||||
|
% Set gain codes for array 2
|
||||||
|
xp = sub2gain(nch);
|
||||||
|
if xp == -Inf
|
||||||
|
calibGainCode(nch+4) = 0;
|
||||||
|
else
|
||||||
|
calibGainCode(nch+4) = round(interp1(subArray2_NormalizedGainProfile(:,nch),gaincode,xp));
|
||||||
|
end
|
||||||
|
|
||||||
|
% Make sure the values of the gain code is always <= 127
|
||||||
|
calibGainCode(calibGainCode>127 | isnan(calibGainCode)) = 127;
|
||||||
|
end
|
||||||
|
|
||||||
|
% Set element phase and gain
|
||||||
|
bf.RxPhase(:) = phases;
|
||||||
|
bf.RxGain(:) = calibGainCode;
|
||||||
|
|
||||||
|
% Collect data
|
||||||
|
bf.LatchRxSettings();
|
||||||
|
receivedSig_HW = rx();
|
||||||
|
|
||||||
|
% Get the steering weights for the digital channels, we need to flip
|
||||||
|
% them before applying the steering vector because the receive data is
|
||||||
|
% out of order
|
||||||
|
flipdigitalweights = [digitalWeights(2);digitalWeights(1)];
|
||||||
|
arraysteerweights = arraySteer(signal_freq,currentangle);
|
||||||
|
adjustedarrayweights = arraysteerweights .* flipdigitalweights;
|
||||||
|
adjustedarrayweights = [adjustedarrayweights(2);adjustedarrayweights(1)];
|
||||||
|
|
||||||
|
% Apply the digital steering weights
|
||||||
|
receivedSig_HW_sum = receivedSig_HW * conj(adjustedarrayweights);
|
||||||
|
|
||||||
|
% Get the array factor
|
||||||
|
receivedFFT = fft(receivedSig_HW_sum);
|
||||||
|
ArrayFactor(ii) = (max(abs(receivedFFT)));
|
||||||
|
end
|
||||||
|
|
||||||
|
%% Compare the measured array factor and model
|
||||||
|
[~,ind] = max(ArrayFactor);
|
||||||
|
EmitterAz = steeringAngle(ind);
|
||||||
|
figure(101)
|
||||||
|
subarrayWeights = conj(subarraySteer(signal_freq,EmitterAz));
|
||||||
|
arrayWeights = arraySteer(signal_freq,EmitterAz);
|
||||||
|
pattern(arrayModel,signal_freq,-90:90,0,'CoordinateSystem', ...
|
||||||
|
'Rectangular','Type','powerdb','ElementWeights',[subarrayWeights,subarrayWeights],'Weights',arrayWeights)
|
||||||
|
hold on;
|
||||||
|
|
||||||
|
% Plot the measured data and the model
|
||||||
|
plot(steeringAngle,mag2db(ArrayFactor./max(abs(ArrayFactor))))
|
||||||
|
|
||||||
|
%%
|
||||||
|
bf.release();
|
||||||
|
rx.release();
|
||||||
|
|
@ -0,0 +1,352 @@
|
||||||
|
function CalibrationData = calibrationRoutine(fc_hb100)
|
||||||
|
|
||||||
|
% Setup:
|
||||||
|
%
|
||||||
|
% Place the HB100 in front of the Phaser - 0 degree azimuth. It should be
|
||||||
|
% sufficiently far from the antenna so that the wavefront is approximately
|
||||||
|
% planar.
|
||||||
|
%
|
||||||
|
% Notes:
|
||||||
|
%
|
||||||
|
% The amplitude and phase of all 8 analog channels as well as the two
|
||||||
|
% digital channels must be calibrated so that the amplitudes in each
|
||||||
|
% channel are the same and the phase shifts align as expected during
|
||||||
|
% steering.
|
||||||
|
%
|
||||||
|
% The order of the calibration steps is described below.
|
||||||
|
%
|
||||||
|
% 1. Course Analog Amplitude Calibration: The first calibration step is an
|
||||||
|
% initial amplitude calibration so that the amplitude in each of the 4
|
||||||
|
% elements in each of the 2 subarrays are the same. This is done by
|
||||||
|
% independently measuring the signal amplitude in each channel when the gain
|
||||||
|
% is set to maximum.The gain is set so that all of the channel signal
|
||||||
|
% amplitudes match the lowest signal amplitude channel.
|
||||||
|
%
|
||||||
|
% 2. Analog Phase Calibration: The second calibration step is to account for
|
||||||
|
% the different phase shift in each analog channel. For each subarray,
|
||||||
|
% select a reference channel. Then measure the phase of other channels
|
||||||
|
% within the subarray with respect to the reference channel. The search is
|
||||||
|
% brute force, by sweeping all the possible phases on the chip.
|
||||||
|
%
|
||||||
|
% 3. Fine Analog Amplitude Calibration: Changing the default phase shift in
|
||||||
|
% each analog channel in step (2) causes the amplitude of the signal in
|
||||||
|
% each channel to change. Therefore, the amplitude calibration is performed
|
||||||
|
% again.
|
||||||
|
%
|
||||||
|
% 4. Digital Amplitude Calibration: Once the analog channels have been
|
||||||
|
% calibrated, the difference in amplitude between the two digital channels
|
||||||
|
% is measured. Whenever the digital channel signals are combined, an
|
||||||
|
% amplitude adjustment is applied based on this different in amplitude.
|
||||||
|
%
|
||||||
|
% 5. Digital Phase Calibration: The signal phase into each of the two
|
||||||
|
% digital channels will not necessarily align. The phase difference is
|
||||||
|
% measured by shifting the phase of channel 2 until the amplitude of the
|
||||||
|
% combined signal is maximized. This phase shift is applied when the two
|
||||||
|
% digital signals are combined.
|
||||||
|
|
||||||
|
%% Setup
|
||||||
|
|
||||||
|
% Setup antenna and model
|
||||||
|
[rx,bf,~] = setupAntenna(fc_hb100);
|
||||||
|
|
||||||
|
% Setup calibration data storage object
|
||||||
|
CalibrationData = CalibrationDataFormat();
|
||||||
|
|
||||||
|
% Setup the inital analog and digital antenna weights. These are the values
|
||||||
|
% that get adjusted during calibration. The amplitude and phase of the weights
|
||||||
|
% represent the gain and phase adjustments that will be made on each channel.
|
||||||
|
% Initially there is no phase shift or amplitude adjustment.
|
||||||
|
analogWeights = ones(4,2);
|
||||||
|
digitalWeights = ones(2,1);
|
||||||
|
|
||||||
|
% Store uncalibrated weights for later analysis
|
||||||
|
CalibrationData.CalibrationWeights.UncalibratedWeights.AnalogWeights = analogWeights;
|
||||||
|
CalibrationData.CalibrationWeights.UncalibratedWeights.DigitalWeights = digitalWeights;
|
||||||
|
|
||||||
|
%% Course Amplitude Calibration
|
||||||
|
% The amplitude in each analog channel is measured when the gain is
|
||||||
|
% set to the maximum level. Gain in each channel is adjusted to account
|
||||||
|
% for differences.
|
||||||
|
|
||||||
|
% Set the gain of all 8 channels to maximum.
|
||||||
|
bf.RxGain(:) = 127;
|
||||||
|
|
||||||
|
% Setup data variables
|
||||||
|
nCapture = 20;
|
||||||
|
rx1data = zeros(1024,nCapture,4);
|
||||||
|
rx2data = zeros(1024,nCapture,4);
|
||||||
|
|
||||||
|
for nCh = 1:4
|
||||||
|
% Turn off all the channels.
|
||||||
|
bf.RxPowerDown(:) = 1;
|
||||||
|
|
||||||
|
% Turn on channels under test (subarray 1 and subarray 2)
|
||||||
|
bf.RxPowerDown(nCh) = 0;
|
||||||
|
bf.RxPowerDown(nCh+4) = 0;
|
||||||
|
bf.LatchRxSettings();
|
||||||
|
|
||||||
|
% Capture multiple snapshots
|
||||||
|
for ncapture = 1 : nCapture
|
||||||
|
rx();
|
||||||
|
receivedSig = rx();
|
||||||
|
rx1data(:,ncapture,nCh) = receivedSig(:,2);
|
||||||
|
rx2data(:,ncapture,nCh) = receivedSig(:,1);
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
% Turn all channels back on
|
||||||
|
bf.RxPowerDown(:) = 0;
|
||||||
|
|
||||||
|
% Calculate the average amplitude for each element in each subarray
|
||||||
|
avgamp1 = mean(max(abs(fft(rx1data))));
|
||||||
|
avgamp2 = mean(max(abs(fft(rx2data))));
|
||||||
|
|
||||||
|
% Reshape into a vector
|
||||||
|
avgamp1 = reshape(avgamp1,[1 4]);
|
||||||
|
avgamp2 = reshape(avgamp2,[1 4]);
|
||||||
|
|
||||||
|
% Scale each amplitude value to the minimum measured amplitude value
|
||||||
|
sub1gain = min(avgamp1) ./ avgamp1;
|
||||||
|
sub2gain = min(avgamp2) ./ avgamp2;
|
||||||
|
|
||||||
|
% Plot the analog amplitude calibration values
|
||||||
|
helperPlotElementGainCalibration(avgamp1,sub1gain,avgamp2,sub2gain);
|
||||||
|
|
||||||
|
% Update analog weights with array gain calibration values
|
||||||
|
analogWeights = analogWeights .* [sub1gain',sub2gain'];
|
||||||
|
|
||||||
|
% Store the calibration data for later analysis
|
||||||
|
CalibrationData.AnalogAmplitudeCalibration.CourseSubarray1Data = rx1data;
|
||||||
|
CalibrationData.AnalogAmplitudeCalibration.CourseSubarray2Data = rx2data;
|
||||||
|
CalibrationData.CalibrationWeights.AnalogCourseAmplitudeWeights.AnalogWeights = analogWeights;
|
||||||
|
|
||||||
|
%% Calibrate phase
|
||||||
|
% Place the emitter in front of the phased array.
|
||||||
|
% Turn on two adjacent channel. On the first channel put 0 phase, and on
|
||||||
|
% the adjacent channel sweep the phase shift setting from 0 to 360. Minimum
|
||||||
|
% signal strength occurs when the phase offset between channels is 180
|
||||||
|
% degrees. The calibration value is set such that the phase shift is
|
||||||
|
% actually 180 degrees when shifter is set to 180 degrees.
|
||||||
|
|
||||||
|
% Setup phase steps to test and variables to hold data
|
||||||
|
PhaseResolutionBits = 7;
|
||||||
|
phase_step_size = 360 / (2 ^ PhaseResolutionBits);
|
||||||
|
channel2phase = double(0:phase_step_size:360);
|
||||||
|
rawdata1 = zeros(rx.SamplesPerFrame,numel(channel2phase),3);
|
||||||
|
rawdata2 = zeros(rx.SamplesPerFrame,numel(channel2phase),3);
|
||||||
|
|
||||||
|
% Set the reference channel and channels under test
|
||||||
|
referencechannel = 1;
|
||||||
|
testchannels = 2:4;
|
||||||
|
|
||||||
|
% set the receiver gain based on the amplitude calibration. The gain codes
|
||||||
|
% are set based on data that was previously captured to determine gain code
|
||||||
|
% correspondance to actual gain.
|
||||||
|
bf.RxGain = helperGainCodes(analogWeights);
|
||||||
|
|
||||||
|
% Loop through each channel under test
|
||||||
|
for nChannel = testchannels
|
||||||
|
% Set all phase shifts to 0
|
||||||
|
bf.RxPhase(:) = 0;
|
||||||
|
|
||||||
|
% Power down all elements
|
||||||
|
bf.RxPowerDown(:) = 1;
|
||||||
|
|
||||||
|
% Turn on element 1 and element under test subarray 1
|
||||||
|
bf.RxPowerDown(referencechannel) = 0;
|
||||||
|
bf.RxPowerDown(nChannel) = 0;
|
||||||
|
|
||||||
|
% Turn on element 1 and element under test subarray 2
|
||||||
|
bf.RxPowerDown(referencechannel+4) = 0;
|
||||||
|
bf.RxPowerDown(nChannel+4) = 0;
|
||||||
|
bf.LatchRxSettings();
|
||||||
|
|
||||||
|
% Loop through each phase offset, set element under test phase shifter,
|
||||||
|
% capture data.
|
||||||
|
for ii = 1 : numel(channel2phase)
|
||||||
|
% Set phase for subarray 1 and 2 element
|
||||||
|
bf.RxPhase(nChannel) = channel2phase(ii);
|
||||||
|
bf.RxPhase(nChannel+4) = channel2phase(ii);
|
||||||
|
bf.LatchRxSettings();
|
||||||
|
|
||||||
|
% Capture and store data
|
||||||
|
rx();
|
||||||
|
receivedSig_HW = rx();
|
||||||
|
rawdata1(:,ii,nChannel-1) = receivedSig_HW(:,2);
|
||||||
|
rawdata2(:,ii,nChannel-1) = receivedSig_HW(:,1);
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
% Get signal amplitude for both subarrays
|
||||||
|
amp1 = max(abs(fft(rawdata1)),[],1);
|
||||||
|
amp2 = max(abs(fft(rawdata2)),[],1);
|
||||||
|
|
||||||
|
% Reshape into a 2d array which is Number Phases x Number Elements
|
||||||
|
sub1amplitudes = reshape(amp1,[numel(channel2phase) 3]);
|
||||||
|
sub2amplitudes = reshape(amp2,[numel(channel2phase) 3]);
|
||||||
|
|
||||||
|
% Get location of min amplitude
|
||||||
|
[~,phase1Idx] = min(sub1amplitudes,[],1);
|
||||||
|
[~,phase2Idx] = min(sub2amplitudes,[],1);
|
||||||
|
|
||||||
|
% Get calibration phase by substracting 180 from the minimum phase location
|
||||||
|
cal1phase = [0;wrapTo360(channel2phase(phase1Idx)-180)'];
|
||||||
|
cal2phase = [0;wrapTo360(channel2phase(phase2Idx)-180)'];
|
||||||
|
|
||||||
|
% Plot the analog phase shift information
|
||||||
|
helperPlotAnalogPhaseCalibration(channel2phase,sub1amplitudes,sub2amplitudes);
|
||||||
|
|
||||||
|
% Convert calibration phase to a phase shift for the element weights, and
|
||||||
|
% update analog weights
|
||||||
|
phaseSteer = exp(deg2rad([cal1phase,cal2phase])*1i);
|
||||||
|
analogWeights = analogWeights .* phaseSteer;
|
||||||
|
|
||||||
|
% Store recorded data for later analysis
|
||||||
|
CalibrationData.AnalogPhaseCalibration.PhaseSetting = channel2phase;
|
||||||
|
CalibrationData.AnalogPhaseCalibration.Subarray1Measurements = rawdata1;
|
||||||
|
CalibrationData.AnalogPhaseCalibration.Subarray2Measurements = rawdata2;
|
||||||
|
CalibrationData.CalibrationWeights.AnalogPhaseWeights.AnalogWeights = analogWeights;
|
||||||
|
|
||||||
|
%% Fine Grain Calibration Data
|
||||||
|
|
||||||
|
% The amplitude in each analog channel is measured when the gain is
|
||||||
|
% set to the maximum level with the new default phase shifts applied.
|
||||||
|
% Gain in each channel is adjusted to account for differences. This is the
|
||||||
|
% exact same process that was used for the analog course amplitude
|
||||||
|
% calibration, although now the phase shifter values are set to the default
|
||||||
|
% determined in the previous section.
|
||||||
|
|
||||||
|
% Set the gain of all 8 channels to maximum.
|
||||||
|
bf.RxGain(:) = 127;
|
||||||
|
|
||||||
|
% Set the phase shifts based on the new analog weights
|
||||||
|
phaseshifts = wrapTo360(rad2deg(angle(analogWeights)));
|
||||||
|
bf.RxPhase(:) = [phaseshifts(:,1)',phaseshifts(:,2)'];
|
||||||
|
|
||||||
|
% Setup data variables
|
||||||
|
nCapture = 20;
|
||||||
|
rx1data = zeros(1024,nCapture,4);
|
||||||
|
rx2data = zeros(1024,nCapture,4);
|
||||||
|
|
||||||
|
for nCh = 1:4
|
||||||
|
% Turn off all the channels.
|
||||||
|
bf.RxPowerDown(:) = 1;
|
||||||
|
|
||||||
|
% Turn on channels under test (subarray 1 and subarray 2)
|
||||||
|
bf.RxPowerDown(nCh) = 0;
|
||||||
|
bf.RxPowerDown(nCh+4) = 0;
|
||||||
|
bf.LatchRxSettings();
|
||||||
|
|
||||||
|
% Capture multiple snapshots
|
||||||
|
for ncapture = 1 : nCapture
|
||||||
|
rx();
|
||||||
|
receivedSig = rx();
|
||||||
|
rx1data(:,ncapture,nCh) = receivedSig(:,2);
|
||||||
|
rx2data(:,ncapture,nCh) = receivedSig(:,1);
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
% Turn all channels back on
|
||||||
|
bf.RxPowerDown(:) = 0;
|
||||||
|
|
||||||
|
% Calculate the average amplitude for each element in each subarray
|
||||||
|
avgamp1 = mean(max(abs(fft(rx1data))));
|
||||||
|
avgamp2 = mean(max(abs(fft(rx2data))));
|
||||||
|
|
||||||
|
% Reshape into a vector
|
||||||
|
avgamp1 = reshape(avgamp1,[1 4]);
|
||||||
|
avgamp2 = reshape(avgamp2,[1 4]);
|
||||||
|
|
||||||
|
% Scale each amplitude value to the minimum measured amplitude value
|
||||||
|
sub1gain = min(avgamp1) ./ avgamp1;
|
||||||
|
sub2gain = min(avgamp2) ./ avgamp2;
|
||||||
|
|
||||||
|
% Normalize the weights back to amplitude 1
|
||||||
|
analogWeights = analogWeights ./ abs(analogWeights);
|
||||||
|
|
||||||
|
% Update analog weights with array gain calibration values
|
||||||
|
analogWeights = analogWeights .* [sub1gain',sub2gain'];
|
||||||
|
|
||||||
|
% Store the calibration data for later analysis
|
||||||
|
CalibrationData.AnalogAmplitudeCalibration.FineSubarray1Data = rx1data;
|
||||||
|
CalibrationData.AnalogAmplitudeCalibration.FineSubarray2Data = rx2data;
|
||||||
|
CalibrationData.CalibrationWeights.AnalogFineAmplitudeWeights.AnalogWeights = analogWeights;
|
||||||
|
|
||||||
|
%% Calibrate the two digital channels on Pluto
|
||||||
|
% After the analog channels have been calibrated, collect data with
|
||||||
|
% analog calibration value settings and calibrate the digital channels for
|
||||||
|
% amplitude and phase.
|
||||||
|
|
||||||
|
% Collect data with analog weight settings
|
||||||
|
analogcaldata = helperSteerAnalog(bf,rx,analogWeights);
|
||||||
|
|
||||||
|
% Store calibration data for later analysis
|
||||||
|
CalibrationData.DigitalCalibration.MeasuredData = analogcaldata;
|
||||||
|
|
||||||
|
% Calculate the channel calibration gain by normalizing the channel
|
||||||
|
% amplitudes to the max channel amplitude
|
||||||
|
channelamplitude = max(abs(fft(analogcaldata)));
|
||||||
|
gain = max(channelamplitude) ./ channelamplitude;
|
||||||
|
digitalWeights = digitalWeights .* gain';
|
||||||
|
|
||||||
|
% Save the weights for later analysis
|
||||||
|
CalibrationData.CalibrationWeights.DigitalAmplitudeWeights.AnalogWeights = analogWeights;
|
||||||
|
CalibrationData.CalibrationWeights.DigitalAmplitudeWeights.DigitalWeights = digitalWeights;
|
||||||
|
|
||||||
|
% Calculate the channel calibration phase by steering channel 2 from 0 to
|
||||||
|
% 360 and finding the maximum combined channel amplitude
|
||||||
|
channel2phase = deg2rad(0:360);
|
||||||
|
st_vec = [ones(size(channel2phase)); exp(1i*channel2phase)];
|
||||||
|
sig = analogcaldata*conj(st_vec);
|
||||||
|
sigfft = fft(sig);
|
||||||
|
combinedamplitude = max(abs(sigfft));
|
||||||
|
[~, phaseIdx] = max(combinedamplitude);
|
||||||
|
|
||||||
|
% Plot the digital phase offset pattern and calibration value
|
||||||
|
ax = axes(figure); hold(ax,"on");
|
||||||
|
title(ax,"Digital Phase Calibration"); ylabel(ax,"dB"); xlabel(ax,"Channel 2 Phase Offset (deg)");
|
||||||
|
plot(ax,channel2phase,combinedamplitude,"DisplayName","Combined Channel Power");
|
||||||
|
scatter(ax,channel2phase(phaseIdx),combinedamplitude(phaseIdx),"DisplayName","Selected Phase Offset");
|
||||||
|
legend('location','southeast');
|
||||||
|
|
||||||
|
% Set the new digital weights
|
||||||
|
defaultsteervec = st_vec(:,phaseIdx);
|
||||||
|
digitalWeights = digitalWeights .* defaultsteervec;
|
||||||
|
|
||||||
|
% Save the final calibration weights
|
||||||
|
CalibrationData.CalibrationWeights.FinalCalibrationWeights.AnalogWeights = analogWeights;
|
||||||
|
CalibrationData.CalibrationWeights.FinalCalibrationWeights.DigitalWeights = digitalWeights;
|
||||||
|
|
||||||
|
%% Release Hardware
|
||||||
|
bf.release(); delete(bf);
|
||||||
|
rx.release(); delete(rx);
|
||||||
|
|
||||||
|
%% Plot final data: uncalibrated data vs. calibrated data vs. simulated data
|
||||||
|
|
||||||
|
% Use a custom class called AntennaInteractor to help steer the antenna
|
||||||
|
initialcalvalues = CalibrationData.CalibrationWeights.UncalibratedWeights;
|
||||||
|
antennaInteractor = AntennaInteractor(fc_hb100,initialcalvalues);
|
||||||
|
steerangles = -90:0.5:90;
|
||||||
|
|
||||||
|
% Capture the pattern with the initial calibration values
|
||||||
|
[initialpattern,~] = antennaInteractor.capturePattern(steerangles);
|
||||||
|
initialamp = mag2db(helperGetAmplitude(initialpattern));
|
||||||
|
|
||||||
|
% Capture the pattern with the final calibration values
|
||||||
|
finalcalvalues = CalibrationData.CalibrationWeights.FinalCalibrationWeights;
|
||||||
|
antennaInteractor.updateCalibration(finalcalvalues);
|
||||||
|
[finalpattern,~] = antennaInteractor.capturePattern(steerangles);
|
||||||
|
finalamp = mag2db(helperGetAmplitude(finalpattern));
|
||||||
|
|
||||||
|
% Simulate the expected antenna pattern
|
||||||
|
rxpos = [0;0;0]; % phaser at 0
|
||||||
|
txpos = [0;10;0]; % transmitter 10 meters away at 0 boresight
|
||||||
|
simpattern = mag2db(helperSimulateAntennaSteering(fc_hb100,rxpos,txpos,steerangles));
|
||||||
|
|
||||||
|
% Plot data
|
||||||
|
patternax = axes(figure); hold(patternax,"on"); legend(patternax);
|
||||||
|
xlabel(patternax,"Steer Angle (deg)"); ylabel(patternax,"Amplitude (dB)"); title(patternax,"Calibration Effect");
|
||||||
|
plot(patternax,steerangles,initialamp - max(initialamp),'DisplayName','Uncalibrated Array Factor');
|
||||||
|
plot(patternax,steerangles,finalamp - max(finalamp),'DisplayName','Calibrated Array Factor');
|
||||||
|
plot(patternax,steerangles,simpattern - max(simpattern),'DisplayName','Simulated Array Factor');
|
||||||
|
end
|
||||||
Binary file not shown.
|
|
@ -0,0 +1,4 @@
|
||||||
|
function cleanupAntenna(rx,bf)
|
||||||
|
rx.release();
|
||||||
|
bf.release();
|
||||||
|
end
|
||||||
Binary file not shown.
|
|
@ -0,0 +1,58 @@
|
||||||
|
function txFrequency = findTxFrequency()
|
||||||
|
% Setup:
|
||||||
|
%
|
||||||
|
% Place the HB100 in front of the Phaser - 0 degree azimuth.
|
||||||
|
%
|
||||||
|
% Notes:
|
||||||
|
%
|
||||||
|
% The frequency of the phaser is swept between 10 and 10.5 GHz. The peak
|
||||||
|
% frequency is measured. This is assumed to be the frequency of the HB100.
|
||||||
|
%
|
||||||
|
|
||||||
|
% Setup the frequencies to scan.
|
||||||
|
f_start = 10.e9;
|
||||||
|
f_stop = 10.5e9;
|
||||||
|
f_step = 5e6;
|
||||||
|
fvec = f_start : f_step : f_stop;
|
||||||
|
|
||||||
|
% Setup the antenna, setting the frequency to f_start.
|
||||||
|
[rx,bf,~] = setupAntenna(f_start);
|
||||||
|
|
||||||
|
% Setup variables for capturing scan amplitude and frequency.
|
||||||
|
full_ampl = [];
|
||||||
|
full_freqs = [];
|
||||||
|
N = rx.SamplesPerFrame;
|
||||||
|
|
||||||
|
% Loop through the frequency vector and save receive data at each center
|
||||||
|
% frequency.
|
||||||
|
for centerfrequency = fvec
|
||||||
|
% The LO is set to 4x the Frequency setting.
|
||||||
|
bf.Frequency = (centerfrequency + rx.CenterFrequency)/4;
|
||||||
|
rx();
|
||||||
|
|
||||||
|
% Capture the data, sum the channels, and convert to the frequency domain
|
||||||
|
data = rx();
|
||||||
|
data = sum(data,2);
|
||||||
|
famplitude = mag2db(1/N * fftshift(abs(fft(data))));
|
||||||
|
full_ampl = [full_ampl, famplitude];
|
||||||
|
|
||||||
|
% Get the frequency span for this data sample
|
||||||
|
df = rx.SamplingRate/N;
|
||||||
|
band = (-rx.SamplingRate/2 : df : rx.SamplingRate/2 - df);
|
||||||
|
freqspan = centerfrequency-band;
|
||||||
|
full_freqs = [full_freqs, freqspan'];
|
||||||
|
end
|
||||||
|
|
||||||
|
% Get the max amplitude for each measurement
|
||||||
|
[maxamplitudes,maxidxs] = max(full_ampl);
|
||||||
|
|
||||||
|
% Get the max amplitude in the whole dataset
|
||||||
|
[~,maxframeidx] = max(maxamplitudes);
|
||||||
|
maxdatapointidx = maxidxs(maxframeidx);
|
||||||
|
|
||||||
|
txFrequency = full_freqs(maxdatapointidx,maxframeidx);
|
||||||
|
|
||||||
|
ax = axes(figure);
|
||||||
|
plot(ax,full_freqs/1e9,full_ampl); xlabel('Frequency (GHz)'); ylabel('Amplitude (dB)');
|
||||||
|
title(ax,['HB100 Frequency = ' num2str(txFrequency/1e9) 'GHz']);
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,13 @@
|
||||||
|
function amplitude = helperCalculateAmplitude(data,maxvalue)
|
||||||
|
% Get the signal amplitude
|
||||||
|
|
||||||
|
% Scale data
|
||||||
|
datascaled = data / maxvalue;
|
||||||
|
[nsamples,~] = size(data);
|
||||||
|
|
||||||
|
% Convert the signal to the frequency domain
|
||||||
|
fexampledata = mag2db(abs(fft(datascaled)) / nsamples);
|
||||||
|
|
||||||
|
% Amplitude is the largest frequency value
|
||||||
|
amplitude = max(fexampledata);
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,36 @@
|
||||||
|
function calibGainCode = helperGainCodes(analogWeights)
|
||||||
|
% get gain for each subarray
|
||||||
|
sub1weights = analogWeights(:,1);
|
||||||
|
sub2weights = analogWeights(:,2);
|
||||||
|
sub1gain = getGain(sub1weights);
|
||||||
|
sub2gain = getGain(sub2weights);
|
||||||
|
|
||||||
|
% Loading the measured gain profiles
|
||||||
|
load('GainProfile.mat','subArray1_NormalizedGainProfile','subArray2_NormalizedGainProfile','gaincode');
|
||||||
|
|
||||||
|
calibGainCode = zeros(1,8);
|
||||||
|
for nch = 1 : 4
|
||||||
|
|
||||||
|
xp = sub1gain(nch);
|
||||||
|
if xp == -Inf
|
||||||
|
calibGainCode(nch) = 0;
|
||||||
|
else
|
||||||
|
calibGainCode(nch) = round(interp1(subArray1_NormalizedGainProfile(:,nch),gaincode,xp));
|
||||||
|
end
|
||||||
|
|
||||||
|
xp = sub2gain(nch);
|
||||||
|
if xp == -Inf
|
||||||
|
calibGainCode(nch+4) = 0;
|
||||||
|
else
|
||||||
|
calibGainCode(nch+4) = round(interp1(subArray2_NormalizedGainProfile(:,nch),gaincode,xp));
|
||||||
|
end
|
||||||
|
end
|
||||||
|
% Make sure the values of the gain code is always <= 127
|
||||||
|
calibGainCode(calibGainCode>127 | isnan(calibGainCode)) = 127;
|
||||||
|
|
||||||
|
function gain = getGain(weights)
|
||||||
|
amp = abs(weights);
|
||||||
|
gain = mag2db(amp);
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
@ -0,0 +1,3 @@
|
||||||
|
function [amp] = helperGetAmplitude(signal)
|
||||||
|
amp = max(abs(fft(signal)));
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,8 @@
|
||||||
|
function phase = helperGetPhase(signal)
|
||||||
|
fsig = fft(signal);
|
||||||
|
[~,ampidx] = max(fsig);
|
||||||
|
phase = zeros(1,numel(ampidx));
|
||||||
|
for i = 1:numel(ampidx)
|
||||||
|
phase(i) = rad2deg(angle(fsig(ampidx(i),i)));
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,19 @@
|
||||||
|
function helperPlotAnalogPhaseCalibration(phasesetting,sub1amplitudes,sub2amplitudes)
|
||||||
|
% Visualize the element-wise phase calibration data for the entire
|
||||||
|
% array.
|
||||||
|
figure; tiledlayout(1,2); nexttile();
|
||||||
|
helperPlotPhaseSubarrayData("Subarray 1",phasesetting,mag2db(sub1amplitudes)); nexttile();
|
||||||
|
helperPlotPhaseSubarrayData("Subarray 2",phasesetting,mag2db(sub2amplitudes));
|
||||||
|
end
|
||||||
|
|
||||||
|
function helperPlotPhaseSubarrayData(name, phasesetting, phaseOffsetAmplDb)
|
||||||
|
% Visualize the element-wise phase calibration data for a subarray.
|
||||||
|
lines = plot(phasesetting, phaseOffsetAmplDb);
|
||||||
|
lines(1).DisplayName = "Element 2";
|
||||||
|
lines(2).DisplayName = "Element 3";
|
||||||
|
lines(3).DisplayName = "Element 4";
|
||||||
|
title([name,' - Phase Calibration Data'])
|
||||||
|
ylabel("Amplitude (dB) Element X + Element 1")
|
||||||
|
xlabel("Test Element Phase Shift (deg)")
|
||||||
|
legend("Location","southoutside")
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,41 @@
|
||||||
|
function [array1gaincal,array2gaincal] = helperPlotElementGainCalibration(sub1meanamp,sub1gaincal,sub2meanamp,sub2gaincal)
|
||||||
|
% Calculate and visualize the element-wise amplitude calibration for
|
||||||
|
% both subarrays.
|
||||||
|
|
||||||
|
sub1meanamp = mag2db(sub1meanamp);
|
||||||
|
sub1gaincal = mag2db(sub1gaincal);
|
||||||
|
sub2meanamp = mag2db(sub2meanamp);
|
||||||
|
sub2gaincal = mag2db(sub2gaincal);
|
||||||
|
|
||||||
|
% Setup figure
|
||||||
|
figure; tiledlayout(1,2); a = nexttile();
|
||||||
|
|
||||||
|
% Calculate and plot the gain calibration for subarray 1
|
||||||
|
array1gaincal = helperElementSubarrayGainCalibration(a,'Subarray 1',sub1meanamp, sub1gaincal); a = nexttile();
|
||||||
|
|
||||||
|
% Calculate and plot the gain calibration for subarray 2
|
||||||
|
array2gaincal = helperElementSubarrayGainCalibration(a, 'Subarray 2', sub2meanamp, sub2gaincal);
|
||||||
|
end
|
||||||
|
|
||||||
|
function arraygaincal = helperElementSubarrayGainCalibration(ax,name,amplitudes,arraygaincal)
|
||||||
|
% Calculate and visualize the element-wise amplitude calibration for
|
||||||
|
% one subarray.
|
||||||
|
|
||||||
|
hold(ax,"on");
|
||||||
|
|
||||||
|
% Normalize amplitude for each element in the array
|
||||||
|
dbNormAmplitudes = amplitudes - max(amplitudes);
|
||||||
|
|
||||||
|
% Plot normalized amplitudes and gain adjustments
|
||||||
|
b = bar(ax,[dbNormAmplitudes',arraygaincal'],'stacked');
|
||||||
|
b(1).DisplayName = "Initial Normalized Amplitude";
|
||||||
|
b(2).DisplayName = "Gain Adjustment";
|
||||||
|
|
||||||
|
% Plot a line showing the final amplitude of all elements
|
||||||
|
plot(ax,[0,5],[min(dbNormAmplitudes),min(dbNormAmplitudes)],"DisplayName","Final Element Amplitude","LineWidth",2,"Color","k")
|
||||||
|
|
||||||
|
xlabel('Antenna Element')
|
||||||
|
ylabel('dB');
|
||||||
|
title([name ' - Gain Calibration'])
|
||||||
|
legend('Location','southoutside')
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,18 @@
|
||||||
|
function gain = helperPlotGainCalibration(name, amplitudes)
|
||||||
|
% Normalize amplitude for each element in the array
|
||||||
|
dbNormAmplitudes = mag2db(amplitudes./max(amplitudes));
|
||||||
|
|
||||||
|
% Calculate gain adjustment
|
||||||
|
gain = -mag2db(amplitudes./min(amplitudes));
|
||||||
|
|
||||||
|
% Plot normalized amplitudes and gain adjustments
|
||||||
|
b = bar([dbNormAmplitudes',gain'],'stacked');
|
||||||
|
b(1).DisplayName = "Initial Normalized Amplitude";
|
||||||
|
b(2).DisplayName = "Gain Adjustment";
|
||||||
|
xlabel('Antenna Element')
|
||||||
|
ylabel('dB');
|
||||||
|
title([name ' - Gain Calibration'])
|
||||||
|
legend('Location','southoutside')
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
|
@ -0,0 +1,86 @@
|
||||||
|
function [rxamp,rxphase] = helperSimulateAntennaSteering(fctransmit,rxpos,txpos,steerangle,analogweight,digitalweight,nullangle)
|
||||||
|
% This helper function simulates antenna steering for the ADI workshop.
|
||||||
|
% analogweight and digitalweight are optional inputs that default to 1.
|
||||||
|
arguments
|
||||||
|
fctransmit (1,1) double
|
||||||
|
rxpos (3,1) double
|
||||||
|
txpos (3,1) double
|
||||||
|
steerangle (1,:) double
|
||||||
|
analogweight (4,2) double = ones(4,2)
|
||||||
|
digitalweight (2,1) double = ones(2,1)
|
||||||
|
nullangle = []
|
||||||
|
end
|
||||||
|
|
||||||
|
% Setup the transmitter
|
||||||
|
txelement = phased.IsotropicAntennaElement;
|
||||||
|
radiator = phased.Radiator("Sensor",txelement,"OperatingFrequency",fctransmit);
|
||||||
|
|
||||||
|
% Setup the Phased Array Receiver based on the Phaser specs
|
||||||
|
frange = [10.0e9 10.5e9];
|
||||||
|
sampleRate = 30e6;
|
||||||
|
nsamples = 1024;
|
||||||
|
element = phased.IsotropicAntennaElement('FrequencyRange',frange);
|
||||||
|
hRange = freq2wavelen(frange);
|
||||||
|
spacing = hRange(2)/2;
|
||||||
|
subarrayElements = 4;
|
||||||
|
subarray = phased.ULA('Element',element,'NumElements',subarrayElements,'ElementSpacing',spacing);
|
||||||
|
array = phased.ReplicatedSubarray('Subarray',subarray,'GridSize',[1,2],"SubarraySteering","Custom");
|
||||||
|
collector = phased.Collector("Sensor",array,"OperatingFrequency",fctransmit,"WeightsInputPort",true);
|
||||||
|
|
||||||
|
% CW signal is used
|
||||||
|
signal = ones(nsamples,1);
|
||||||
|
|
||||||
|
% Set up a channel for radiating signal
|
||||||
|
channel = phased.FreeSpace("OperatingFrequency",fctransmit,"SampleRate",sampleRate);
|
||||||
|
|
||||||
|
% Setup geometry
|
||||||
|
rxvel = [0;0;0];
|
||||||
|
txvel = [0;0;0];
|
||||||
|
[~,ang] = rangeangle(rxpos,txpos);
|
||||||
|
|
||||||
|
% Radiate signal
|
||||||
|
sigtx = radiator(signal,ang);
|
||||||
|
|
||||||
|
% Propagate signal
|
||||||
|
sigtx = channel(sigtx,txpos,rxpos,txvel,rxvel);
|
||||||
|
|
||||||
|
% Create steering vector for the two subarray channels
|
||||||
|
steervec = phased.SteeringVector("SensorArray",array);
|
||||||
|
substeervec = phased.SteeringVector("SensorArray",subarray);
|
||||||
|
|
||||||
|
% Receive signal while steering beam
|
||||||
|
rxphase = zeros(1,numel(steerangle));
|
||||||
|
rxamp = zeros(1,numel(steerangle));
|
||||||
|
for steer = steerangle
|
||||||
|
% Create the subarray weights.
|
||||||
|
singlesubweight = substeervec(fctransmit,steer);
|
||||||
|
|
||||||
|
% Create the replicated array weights
|
||||||
|
repweight = steervec(fctransmit,steer);
|
||||||
|
|
||||||
|
% insert a null if a null angle was passed in
|
||||||
|
if ~isempty(nullangle)
|
||||||
|
% Null the subarray
|
||||||
|
nullsubweight = substeervec(fctransmit,nullangle);
|
||||||
|
singlesubweight = getNullSteer(singlesubweight,nullsubweight);
|
||||||
|
|
||||||
|
% null the replicated array
|
||||||
|
nullrepweight = steervec(fctransmit,nullangle);
|
||||||
|
repweight = getNullSteer(repweight,nullrepweight);
|
||||||
|
end
|
||||||
|
|
||||||
|
% Create the full subarray weights
|
||||||
|
subweight = [singlesubweight,singlesubweight] .* analogweight;
|
||||||
|
|
||||||
|
% Receive the signal
|
||||||
|
sigreceive = collector(sigtx,[0;0],repweight,subweight) * digitalweight;
|
||||||
|
rxphase(steer == steerangle) = mean(rad2deg(angle(sigreceive)));
|
||||||
|
rxamp(steer == steerangle) = mean(abs(sigreceive));
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
function nullsteer = getNullSteer(steerweight,nullweight)
|
||||||
|
rn = nullweight'*steerweight/(nullweight'*nullweight);
|
||||||
|
nullsteer = steerweight-nullweight*rn;
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,9 @@
|
||||||
|
function simpattern = helperSimulateDisabledElement(fc,steerangles,iEl)
|
||||||
|
% Simulate what happens when we disable an element on each of the antenna
|
||||||
|
% subarrays.
|
||||||
|
disabletaper = ones(4,2);
|
||||||
|
disabletaper(iEl,:) = 0;
|
||||||
|
rxpos = [0;0;0];
|
||||||
|
txpos = [0;10;0];
|
||||||
|
simpattern = helperSimulateAntennaSteering(fc,rxpos,txpos,steerangles,disabletaper);
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,15 @@
|
||||||
|
function [sumamp,diffamp,phasedelta] = helperSimulateMonopulse(fc_hb100,steerangles)
|
||||||
|
% Simulate the monopulse pattern for the ADI phaser.
|
||||||
|
|
||||||
|
% Get the sum pattern
|
||||||
|
rxpos = [0;0;0];
|
||||||
|
txpos = [0;10;0];
|
||||||
|
[sumamp,sumphase] = helperSimulateAntennaSteering(fc_hb100,rxpos,txpos,steerangles);
|
||||||
|
|
||||||
|
% The diff pattern is generated by setting the digital weights to
|
||||||
|
% [1;-1]
|
||||||
|
analogweights = ones(4,2);
|
||||||
|
digitalweights = [1;-1];
|
||||||
|
[diffamp,diffphase] = helperSimulateAntennaSteering(fc_hb100,rxpos,txpos,steerangles,analogweights,digitalweights);
|
||||||
|
phasedelta = sign(wrapTo180(sumphase-diffphase));
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,8 @@
|
||||||
|
function pattern = helperSimulateNull(fc_hb100,steerangles,nullangle)
|
||||||
|
% Simulate the pattern with a null at the specified angle
|
||||||
|
analogweights = ones(4,2);
|
||||||
|
digitalweights = ones(2,1);
|
||||||
|
rxpos = [0;0;0];
|
||||||
|
txpos = [0;10;0];
|
||||||
|
[pattern,~] = helperSimulateAntennaSteering(fc_hb100,rxpos,txpos,steerangles,analogweights,digitalweights,nullangle);
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,21 @@
|
||||||
|
function sourceaz = helperSourceLocation(CalibrationData)
|
||||||
|
|
||||||
|
[rx,bf,fc_hb100,phaseCal,channelWeights,steeringVec,~] = setupAntenna(CalibrationData);
|
||||||
|
|
||||||
|
% Capture the initial pattern data, find the location of the interferer -
|
||||||
|
% assumed to be higher power
|
||||||
|
steerangles = -90:0.5:90;
|
||||||
|
patternData = helperCapturePattern(steerangles,steeringVec,fc_hb100,bf,rx,phaseCal,channelWeights);
|
||||||
|
amp = helperGetAmplitude(patternData);
|
||||||
|
smoothamp = smooth(amp,20);
|
||||||
|
[~,azidx] = max(smoothamp);
|
||||||
|
sourceaz = steerangles(azidx);
|
||||||
|
|
||||||
|
ax = axes(figure); hold(ax,"on");
|
||||||
|
plot(ax,steerangles,amp,"DisplayName","Scan Pattern")
|
||||||
|
scatter(ax,sourceaz,amp(azidx),"DisplayName","Source Location");
|
||||||
|
legend();
|
||||||
|
|
||||||
|
cleanupAntenna(rx,bf);
|
||||||
|
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,27 @@
|
||||||
|
function rxdata = helperSteerAnalog(bf,rx,analogWeights)
|
||||||
|
sub1weights = analogWeights(:,1);
|
||||||
|
sub2weights = analogWeights(:,2);
|
||||||
|
|
||||||
|
% Set analog phase shifter
|
||||||
|
sub1phase = getPhase(sub1weights);
|
||||||
|
sub2phase = getPhase(sub2weights);
|
||||||
|
phases = [sub1phase',sub2phase'];
|
||||||
|
if ~isequal(bf.RxPhase,phases)
|
||||||
|
bf.RxPhase(:) = phases;
|
||||||
|
end
|
||||||
|
|
||||||
|
% Set analog gain
|
||||||
|
gainCode = helperGainCodes(analogWeights);
|
||||||
|
if ~isequal(bf.RxGain,gainCode)
|
||||||
|
bf.RxGain(:) = gainCode;
|
||||||
|
end
|
||||||
|
|
||||||
|
% receive data
|
||||||
|
bf.LatchRxSettings();
|
||||||
|
rx();
|
||||||
|
rxdata = rx();
|
||||||
|
end
|
||||||
|
|
||||||
|
function phase = getPhase(weights)
|
||||||
|
phase = wrapTo360(rad2deg(angle(weights)));
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,19 @@
|
||||||
|
function [rx,bf,phaserModel] = setupAntenna(fc_hb100)
|
||||||
|
% Setup the Pluto, Phaser, and Phaser Model.
|
||||||
|
|
||||||
|
% Setup the pluto
|
||||||
|
plutoURI = 'ip:192.168.2.1';
|
||||||
|
rx = setupPluto(plutoURI);
|
||||||
|
|
||||||
|
% Setup the phaser
|
||||||
|
phaserURI = 'ip:phaser.local';
|
||||||
|
bf = setupPhaser(rx,phaserURI,fc_hb100);
|
||||||
|
bf.RxPowerDown(:) = 0;
|
||||||
|
bf.RxGain(:) = 127;
|
||||||
|
|
||||||
|
% Create the model of the phaser
|
||||||
|
nElements = 4;
|
||||||
|
nSubarrays = 2;
|
||||||
|
subModel = phased.ULA('NumElements',nElements,'ElementSpacing',bf.ElementSpacing);
|
||||||
|
phaserModel = phased.ReplicatedSubarray("Subarray",subModel,"GridSize",[1,nSubarrays]);
|
||||||
|
end
|
||||||
|
|
@ -0,0 +1,48 @@
|
||||||
|
function bf = setupPhaser(rx,phaserURI,fc_hb100)
|
||||||
|
%% Configure phaser
|
||||||
|
bf = adi.Phaser;
|
||||||
|
bf.uri = phaserURI;
|
||||||
|
bf.SkipInit = true; % Bypass writing all initial attributes to speed things up
|
||||||
|
bf();
|
||||||
|
bf.ElementSpacing = 0.014;
|
||||||
|
% Put device in Rx mode
|
||||||
|
bf.TxRxSwitchControl = {'spi','spi'};
|
||||||
|
bf.Mode(:) = {'Disabled'};
|
||||||
|
bf.BeamMemEnable(:) = false;
|
||||||
|
bf.BiasMemEnable(:) = false;
|
||||||
|
bf.PolState(:) = false;
|
||||||
|
bf.PolSwitchEnable(:) = false;
|
||||||
|
bf.TRSwitchEnable(:) = true;
|
||||||
|
bf.ExternalTRPolarity(:) = true;
|
||||||
|
|
||||||
|
bf.RxVGAEnable(:) = true;
|
||||||
|
bf.RxVMEnable(:) = true;
|
||||||
|
bf.RxLNABiasCurrent(:) = 8;
|
||||||
|
bf.RxVGABiasCurrentVM(:) = 22;
|
||||||
|
|
||||||
|
% Self bias LNAs
|
||||||
|
bf.LNABiasOutEnable(:) = false;
|
||||||
|
|
||||||
|
% Fire them up
|
||||||
|
bf.RxPowerDown(:) = false;
|
||||||
|
bf.Mode(:) = {'Rx'};
|
||||||
|
|
||||||
|
%% Set up PLL
|
||||||
|
bf.Frequency = (fc_hb100 + rx.CenterFrequency) / 4;
|
||||||
|
BW = 500e6 / 4; num_steps = 1000;
|
||||||
|
bf.FrequencyDeviationRange = BW; % frequency deviation range in H1. This is the total freq deviation of the complete freq ramp
|
||||||
|
bf.FrequencyDeviationStep = int16(BW / num_steps); % frequency deviation step in Hz. This is fDEV, in Hz. Can be positive or negative
|
||||||
|
bf.RampMode = "disabled";
|
||||||
|
bf.DelayStartWord = 4095;
|
||||||
|
bf.DelayClockSource = "PFD";
|
||||||
|
bf.DelayStartEnable = false; % delay start
|
||||||
|
bf.RampDelayEnable = false; % delay between ramps.
|
||||||
|
bf.TriggerDelayEnable = false; % triangle delay
|
||||||
|
bf.SingleFullTriangleEnable = false; % full triangle enable/disable -- this is used with the single_ramp_burst mode
|
||||||
|
bf.TriggerEnable = false; % start a ramp with TXdata
|
||||||
|
%% Flatten phaser phase/gain
|
||||||
|
bf.RxGain(:) = 127;
|
||||||
|
bf.RxAttn(:) = 0;
|
||||||
|
bf.RxPhase(:) = 0;
|
||||||
|
bf.RxLNAEnable(:) = true;
|
||||||
|
bf.LatchRxSettings();
|
||||||
|
|
@ -0,0 +1,19 @@
|
||||||
|
function rx = setupPluto(plutoURI)
|
||||||
|
rx = adi.AD9361.Rx('uri', plutoURI);
|
||||||
|
rx.EnabledChannels = [1,2];
|
||||||
|
rx.SamplesPerFrame = 1024;
|
||||||
|
rx.CenterFrequency = 2e9;
|
||||||
|
rx.kernelBuffersCount = 2; % Minimize delay in receive data
|
||||||
|
rx.GainControlModeChannel0 = 'manual';
|
||||||
|
rx.GainControlModeChannel1 = 'manual';
|
||||||
|
rx.GainChannel0 = 6;
|
||||||
|
rx.GainChannel1 = 6;
|
||||||
|
rx.SamplingRate = 30e6;
|
||||||
|
rx();
|
||||||
|
|
||||||
|
tx = adi.AD9361.Tx('uri', plutoURI);
|
||||||
|
tx.EnabledChannels = [1,2];
|
||||||
|
tx.CenterFrequency = rx.CenterFrequency+2e6;
|
||||||
|
tx.AttenuationChannel0 = -89;
|
||||||
|
tx.AttenuationChannel1 = -89;
|
||||||
|
end
|
||||||
Loading…
Reference in New Issue