RIS(지능형 재구성 표면)를 사용한 레이다 센싱

R2024b 이후

소개

RIS(지능형 재구성 표면)는 6G와 같은 미래의 무선 시스템을 위한 핵심 기술입니다. RIS는 다수의 반사 요소로 구성된 직사각형 평면입니다. 이름에서 알 수 있듯이, RIS의 요소들은 원하는 반사 패턴을 구현하기 위해 개별적으로 구성될 수 있습니다. 이 기능 덕분에 RIS를 RF 환경에서 전파 채널을 개선하기 위해 배치할 수 있으며, 특히 LOS(가시선) 링크를 사용할 수 없는 경우에 효과적입니다. 이는 특히 6G 및 미래 무선 시스템에서 유용한데, 이러한 시스템은 mmWave 대역 이상을 대상으로 하며, 이 영역에서는 다중경로 전파가 매우 약해 링크가 LOS 경로에 의존하기 때문입니다. RIS(지능형 재구성 표면) 소개 예제에서는 RIS가 이러한 상황에서 무선 통신 링크를 유지하는 데 어떻게 도움이 되는지 살펴봤습니다.

스펙트럼 리소스가 매우 제한적이기 때문에, 미래의 무선 시스템은 여러 기능을 수행할 것으로 예상됩니다. 일반적인 통신 작업 외에도 미래의 무선 시스템은 센싱 작업도 수행할 수 있을 것입니다. 예를 들어, 60GHz 대역에서 레이다를 이용한 사람 행동 모니터링은 널리 사용되는 응용 분야입니다. 이 예제에서는 타깃이 레이다의 시야 밖에 있는 경우 RIS가 타깃 검출을 개선하는 데 어떻게 도움이 되는지 보여줍니다.

장면 설정

다음 도식에 표시된 장면을 살펴보십시오. 한 방에는 레이다가 있고 다른 방에는 사람이 있습니다. 두 방을 분리하는 벽은 재질에 따라 상당한 전파 손실을 초래할 수 있으며, 이로 인해 레이다와 사람 사이의 직접 경로가 사실상 차단될 수 있습니다.

이 장면을 모델링하기 위해 레이다가 원점에 위치한다고 가정합니다. 이 레이다는 60GHz에서 동작하며, 이는 의료 응용 분야에서 자주 사용되는 대역입니다.

fc = 60e9;
c = physconst('lightspeed');
lambda = c/fc;
pos_trx = [0;0;3];
vel_trx = [0;0;0];
plat_trx = phased.Platform('InitialPosition',pos_trx,'Velocity',vel_trx,'OrientationAxesOutputPort',true);

레이다에는 8-요소 ULA가 장착되어 있습니다. 이러한 장면을 모델링하기 위해, 배열은 120도 섹터 내에서 균일한 조도를 갖는 패턴의 요소들로 구성되어 있습니다. 벽을 명시적으로 모델링하지 않기 때문에, 이처럼 이상화된 패턴을 사용하여 사람이 레이다의 시야 밖에 위치하도록 하며, 그 결과 레이다와 타깃 사이에 직접 경로가 존재하지 않도록 합니다. 따라서 결과적으로 생성되는 배열 패턴의 시야도 약 120도가 됩니다.

antelement = phased.CustomAntennaElement('MagnitudePattern',-inf(181,361));
antelement.MagnitudePattern(:,121:241) = 0;
Ntrx = 8;
antarray = phased.ULA('NumElements',Ntrx,'ElementSpacing',lambda/2,'Element',antelement);

clf;
patternAzimuth(antarray,fc,'Type','powerdb');

사람은 RCS가 1제곱미터인 점 타깃으로 모델링됩니다.

human = phased.RadarTarget('MeanRCS',1,'OperatingFrequency',fc,'PropagationSpeed',c);
pos_human = [3;10;0]; 
speed_human_mph = 6;
vel_human = speed_human_mph*1600/3600*[1/sqrt(2);1/sqrt(2);0];
plat_human = phased.Platform('InitialPosition',pos_human,'Velocity',vel_human,'OrientationAxesOutputPort',true);

RIS 설정

도식에서 타깃이 레이다의 시야 밖에 있음을 알 수 있습니다. 따라서 사용 가능한 LOS 경로가 없으며 레이다가 타깃을 검출할 수 없습니다. 검출가능성을 높이기 위해 장면에 더 많은 레이다를 추가하면, 최소 하나의 직접 경로가 타깃과 레이다 사이에 존재하도록 할 수 있습니다. 그러나 이러한 구성에는 여러 개의 레이다가 필요하므로 비용이 많이 들 수 있습니다. 반면, 전파 환경을 수정할 수 있는 새로운 기법인 RIS는 이러한 문제를 해결하기 위한 대안적인 접근 방식을 제공합니다. RIS는 일반적으로 수동형이므로, 비싼 TR 모듈이 필요하지 않습니다. RIS를 적절한 위치에 배치하면 LOS 경로가 없어도 타깃을 검출할 수 있습니다.

비가시선(NLOS) 경로에서의 손실을 보상할 만큼 충분한 이득을 제공하려면, RIS는 충분한 개수의 요소를 가져야 하며, 문헌에 따르면 적어도 수백 개 이상의 요소가 필요합니다. 이 예제에서는 20×20 배열(총 400개 요소)로 구성된 RIS를 사용합니다. 표면의 각 요소는 반사기 안테나입니다. 60GHz에서 이러한 표면은 10×10 제곱센티미터 공간에 포함될 수 있으므로 실현 가능성이 매우 높습니다. 이 요소에 대한 자세한 내용은 Electromagnetic Analysis of Reconfigurable Intelligent Surface (Antenna Toolbox) 예제를 참조하십시오. RIS는 레이다의 시야 내에서 레이다를 향하도록 배치되어, 송신된 신호가 RIS에서 반사되어 타깃에 도달할 수 있습니다.

riselement = design(reflector,fc);
riselement.Spacing = lambda/2;
riselement.GroundPlaneLength = 0.5*lambda;
riselement.GroundPlaneWidth = 0.5*lambda;
riselement.TiltAxis = [1 0 0];
riselement.Tilt = 90;
Nr_ris = 20;
Nc_ris = 20;
ris = phased.RectangularRIS('Size',[Nr_ris Nc_ris],'Spacing',[lambda/2 lambda/2],'UnitCell',riselement);
risreflector = phased.RISReflector('Surface',ris,'OperatingFrequency',fc);

pos_ris = [10;5;3];
vel_ris = [0;0;0];
plat_ris = phased.Platform('InitialPosition',pos_ris,'Velocity',vel_ris,'InitialOrientationAxes',azelaxes(180,0),'OrientationAxesOutputPort',true);

RIS가 포함된 경우의 장면은 아래와 같이 플로팅됩니다.

fov = beamwidth(antelement,fc);
helperPlotScene({pos_trx,pos_human,pos_ris},{vel_trx,vel_human,vel_ris},fov);

레이다를 사용한 사람 검출

FMCW 신호는 사람 행동 모니터링에 널리 사용되는 파형입니다. 다음 코드 섹션은 레이다에서 수신된 신호를 시뮬레이션합니다. 변수 hasRIS의 체크박스를 선택하면 수신된 신호에 RIS의 효과가 포함됩니다. 그렇지 않으면 RIS가 사용되지 않습니다.

max_range = 50;
ts = 5.5*range2time(max_range,c);
range_res = 0.1;
pulse_bw = rangeres2bw(range_res,c);
fs = 2*pulse_bw;

wav = phased.FMCWWaveform('SampleRate',fs,'SweepBandwidth',pulse_bw,'SweepTime',ts);

Nsweeps = 64;

hasRIS = true;
[y,ang_ris_from_rx,xref] = helperSimulateEcho(fc,fs,c,plat_trx,plat_ris,plat_human,wav,antarray,human,risreflector,Nsweeps,hasRIS);

다음으로, 신호 대 잡음비를 더욱 개선하기 위해 수신된 신호에 빔포밍을 수행합니다. RIS가 알려진 위치에 배치되어 있기 때문에 빔포밍 방향을 알 수 있습니다.

bf = phased.PhaseShiftBeamformer('PropagationSpeed',c,'OperatingFrequency',fc,'DirectionSource','Input port',...
    'SensorArray',antarray);

y_bf = zeros(round(ts*fs),Nsweeps,'like',1i);
for m = 1:Nsweeps
    y_bf(:,m) = bf(y(:,:,m),ang_ris_from_rx);
end

그런 다음, 빔포밍된 신호를 디처프할 수 있습니다. 결과 신호의 거리-도플러 맵이 아래에 표시되어 있습니다.

y_bf_dechirp = dechirp(y_bf,xref);

rd = phased.RangeDopplerResponse('RangeMethod','FFT','PropagationSpeed',c,...
    'SampleRate',fs,'SweepSlope',pulse_bw/ts,'DopplerOutput','Speed','OperatingFrequency',fc);
clf;
rdm_handle = plotResponse(rd,y_bf_dechirp,'Unit','db');
ylim([0 max_range])
xlim([-100 100])
rdm_axis = rdm_handle.Parent;
hold(rdm_axis,'on')
rangesum_truth = norm(pos_trx-pos_ris)+norm(pos_ris-pos_human);
speedsum_truth = radialspeed(pos_ris,vel_ris,pos_trx,vel_trx)+radialspeed(pos_human,vel_human,pos_ris,vel_ris);
plot(speedsum_truth,rangesum_truth,'ko','MarkerSize',10);

이미지에 있는 원은 사람에 대해 예상되는 거리-도플러 위치를 나타냅니다. 이 플롯은 사람이 올바로 검출되었음을 명확하게 보여줍니다. RIS를 사용하지 않고 스크립트를 실행하면 거리-도플러 맵에서 아무것도 검출되지 않습니다.

RIS 기반 스캔

이전 섹션의 시뮬레이션은 RIS를 사용하지 않을 경우 검출되지 않을 사람을 검출하는 데 RIS가 도움이 될 수 있음을 보여줍니다. 또한, RIS를 사용하면 타깃 방향을 알 수 없는 경우 빔을 스캔하여 공간을 탐색할 수 있습니다. 레이다와 RIS가 모두 정지 상태이므로, RIS의 각 요소의 위상을 제어함으로써 빔을 스캔하여 사람 타깃을 탐색할 수 있습니다.

scan_az = -60:0;
scan_el = -20:-13;
[rxsigpow,ang_car_from_ris] = helperSimulateScanning(fc,fs,c,plat_trx,plat_ris,plat_human,wav,antarray,human,risreflector,scan_az,scan_el);

clf;
im_handle = imagesc(scan_az,scan_el,rxsigpow);
xlabel('Azimmuth Angle (deg)');
ylabel('Elevation Angle (deg)');
title('Angular Response Relative to RIS');
im_ax = im_handle.Parent;
hold(im_ax,'on');
plot(ang_car_from_ris(1),ang_car_from_ris(2),'ko','MarkerSize',10);

그림에서 검은색 원으로 표시된 것처럼 사람이 올바른 방향에서 탐색되었습니다. 이전 섹션에서 얻은 거리 및 도플러 정보와 위에서 얻은 방향 정보를 결합하면, 장면에서 사람의 위치를 적절하게 추정할 수 있습니다.

요약

이 예제에서는 RIS를 사용하여 레이다 시스템의 센싱 기능을 개선하는 방법을 보여줍니다. RIS의 도움으로, 레이다의 시야 밖에 있는 타깃을 성공적으로 검출하고 위치를 추정할 수 있습니다.

참고 문헌

[1] Stefano Buzzi, Emanuele Grossi, Marco Lops, and Luca Venturino, Radar Target Detection Aided by Reconfigurable Intelligent Surfaces, IEEE Signal Processing Letters, Vol. 28, 2021

[2] Sudeep Prabhakar Chepuri, Nir Shlezinger, Fan Liu, George C. Alexandropoulos, Stefano Buzzi, and Yonina C. Eldar, Integrated Sensing and Communications with Reconfigurable Intelligent Surfaces, IEEE Signal processing Magazine, September, 2023

헬퍼 함수

에코 시뮬레이션

function [y,ang_ris_from_rx,xref] = helperSimulateEcho(fc,fs,c,plat_trx,plat_ris,plat_car,wav,antarray,car,risreflector,Nsweeps,hasRIS)

tx = phased.Transmitter('PeakPower',db2pow(40)*1e-3,'Gain',10);
rx = phased.Receiver('Gain',10,'NoiseFigure',0,'SampleRate',fs);
stv_antarray = phased.SteeringVector('SensorArray',antarray,'PropagationSpeed',c);

txant = phased.Radiator('Sensor',antarray,'OperatingFrequency',fc,'PropagationSpeed',c,'WeightsInputPort',true);
rxant = phased.Collector('Sensor',antarray,'OperatingFrequency',fc,'PropagationSpeed',c,'WeightsInputPort',true);

tx_car_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
tx_ris_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
ris_car_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
car_rx_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
car_ris_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
ris_rx_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);

Ntrx = getDOF(txant.Sensor);
ts = wav.SweepTime;
y = zeros(round(ts*fs),Ntrx,Nsweeps,'like',1i);
stv_ris = phased.SteeringVector('SensorArray',risreflector.Surface);
for m = 1:Nsweeps
    [pos_trx,vel_trx,ax_trx] = plat_trx(ts);
    [pos_ris,vel_ris,ax_ris] = plat_ris(ts);
    [pos_car,vel_car,ax_car] = plat_car(ts);

    xref = wav();
    x_tx = tx(xref);
    [~,ang_car_from_tx] = rangeangle(pos_car,pos_trx,ax_trx);
    [~,ang_ris_from_tx] = rangeangle(pos_ris,pos_trx,ax_trx);
    x_tx_car = txant(x_tx,ang_car_from_tx,conj(stv_antarray(fc,ang_car_from_tx)));
    y_tx_car = tx_car_chan(x_tx_car,pos_trx,pos_car,vel_trx,vel_car);
    
    [range_tx_from_ris,ang_tx_from_ris] = rangeangle(pos_trx,pos_ris,ax_ris);
    [range_car_from_ris,ang_car_from_ris] = rangeangle(pos_car,pos_ris,ax_ris);
    stv_trx_from_ris = stv_ris(fc,ang_tx_from_ris);
    stv_car_from_ris = stv_ris(fc,ang_car_from_ris);
    
    x_tx_ris = txant(x_tx,ang_ris_from_tx,conj(stv_antarray(fc,ang_ris_from_tx)));
    x_tx_ris_propagated = tx_ris_chan(x_tx_ris,pos_trx,pos_ris,vel_trx,vel_ris);
    y_tx_ris = risreflector(x_tx_ris_propagated,ang_tx_from_ris,ang_car_from_ris,conj(stv_trx_from_ris).*conj(stv_car_from_ris));
    y_tx_ris_car = ris_car_chan(y_tx_ris,pos_ris,pos_car,vel_ris,vel_car);
    
    if hasRIS
        y_car = car(y_tx_car+y_tx_ris_car);
    else
        y_car = car(y_tx_car);
    end
    y_car_rx_propagated = car_rx_chan(y_car,pos_car,pos_trx,vel_car,vel_trx);
    
    ang_rx_from_ris = ang_tx_from_ris;
    y_car_ris_propagated = car_ris_chan(y_car,pos_car,pos_ris,vel_car,vel_ris);
    y_car_ris = risreflector(y_car_ris_propagated,ang_car_from_ris,ang_rx_from_ris,conj(stv_trx_from_ris).*conj(stv_car_from_ris));
    
    y_car_ris_rx_propagated = ris_rx_chan(y_car_ris,pos_ris,pos_trx,vel_ris,vel_trx);
    
    [~,ang_ris_from_rx] = rangeangle(pos_ris,pos_trx,ax_trx);
    [~,ang_car_from_rx] = rangeangle(pos_car,pos_trx,ax_trx);
    if hasRIS
        y_car_rx = rxant([y_car_rx_propagated y_car_ris_rx_propagated],[ang_car_from_rx,ang_ris_from_rx],ones(Ntrx,1));
    else
        y_car_rx = rxant(y_car_rx_propagated,ang_car_from_rx,ones(Ntrx,1));
    end
    y(:,:,m) = rx(y_car_rx);
    
end

end

RIS 스캔

function [rxsigpow,ang_car_from_ris] = helperSimulateScanning(fc,fs,c,plat_trx,plat_ris,plat_car,wav,antarray,car,risreflector,scan_az,scan_el)

tx = phased.Transmitter('PeakPower',db2pow(40)*1e-3,'Gain',10);
rx = phased.Receiver('Gain',10,'NoiseFigure',0,'SampleRate',fs);
stv_antarray = phased.SteeringVector('SensorArray',antarray,'PropagationSpeed',c);

txant = phased.Radiator('Sensor',antarray,'OperatingFrequency',fc,'PropagationSpeed',c,'WeightsInputPort',true);
rxant = phased.Collector('Sensor',antarray,'OperatingFrequency',fc,'PropagationSpeed',c,'WeightsInputPort',true);

tx_car_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
tx_ris_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
ris_car_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
car_rx_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
car_ris_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);
ris_rx_chan = phased.FreeSpace('OperatingFrequency',fc,'SampleRate',fs,'PropagationSpeed',c,...
    'TwoWayPropagation',false,'MaximumDistanceSource','Property','MaximumDistance',500);

bf = phased.PhaseShiftBeamformer('PropagationSpeed',c,'OperatingFrequency',fc,'DirectionSource','Input port',...
    'SensorArray',txant.Sensor);

Ntrx = getDOF(txant.Sensor);
stv_ris = phased.SteeringVector('SensorArray',risreflector.Surface);

ts = wav.SweepTime;
[pos_trx,vel_trx,ax_trx] = plat_trx(ts);
[pos_ris,vel_ris,ax_ris] = plat_ris(ts);
[pos_car,vel_car,ax_car] = plat_car(ts);

xref = wav();
x_tx = tx(xref);
[~,ang_car_from_tx] = rangeangle(pos_car,pos_trx,ax_trx);
[~,ang_ris_from_tx] = rangeangle(pos_ris,pos_trx,ax_trx);
x_tx_car = txant(x_tx,ang_car_from_tx,conj(stv_antarray(fc,ang_car_from_tx)));
y_tx_car = tx_car_chan(x_tx_car,pos_trx,pos_car,vel_trx,vel_car);

[range_tx_from_ris,ang_tx_from_ris] = rangeangle(pos_trx,pos_ris,ax_ris);
[range_car_from_ris,ang_car_from_ris] = rangeangle(pos_car,pos_ris,ax_ris);
stv_trx_from_ris = stv_ris(fc,ang_tx_from_ris);

x_tx_ris = txant(x_tx,ang_ris_from_tx,conj(stv_antarray(fc,ang_ris_from_tx)));
x_tx_ris_propagated = tx_ris_chan(x_tx_ris,pos_trx,pos_ris,vel_trx,vel_ris);

y_tx_ris_car = ris_car_chan(x_tx_ris_propagated,pos_ris,pos_car,vel_ris,vel_car);

y_car = car(y_tx_car+y_tx_ris_car);
y_car_rx_propagated = car_rx_chan(y_car,pos_car,pos_trx,vel_car,vel_trx);
y_car_ris_propagated = car_ris_chan(y_car,pos_car,pos_ris,vel_car,vel_ris);
y_car_ris_rx_propagated = ris_rx_chan(y_car_ris_propagated,pos_ris,pos_trx,vel_ris,vel_trx);

ang_rx_from_ris = ang_tx_from_ris;
[~,ang_ris_from_rx] = rangeangle(pos_ris,pos_trx,ax_trx);
[~,ang_car_from_rx] = rangeangle(pos_car,pos_trx,ax_trx);
rxsigpow = zeros(numel(scan_el),numel(scan_az));
for m = 1:numel(scan_az)
    for n = 1:numel(scan_el)
        scanAngle = [scan_az(m);scan_el(n)];
        stv_scan = stv_ris(fc,scanAngle);
        y_tx_ris = risreflector(y_car_ris_rx_propagated,ang_tx_from_ris,ang_car_from_ris,conj(stv_trx_from_ris).*conj(stv_scan));
        y_car_ris = risreflector(y_tx_ris,ang_car_from_ris,ang_rx_from_ris,conj(stv_trx_from_ris).*conj(stv_scan));
        y_car_rx = rxant([y_car_rx_propagated y_car_ris],[ang_car_from_rx,ang_ris_from_rx],ones(Ntrx,1));
        y = rx(y_car_rx);
        y_bf = bf(y,ang_ris_from_rx);  
        rxsigpow(n,m) = rms(y_bf);
    end
end

end

장면 플로팅

function helperPlotScene(pos,vel,fov)

tp = theaterPlot('XLim',[-10 20],'Ylim',[-10 20],'Zlim',[-10 20]);
trxp = platformPlotter(tp,'DisplayName','Radar','Marker','.');
pos_trx = pos{1};
vel_trx = vel{1};
plotPlatform(trxp,pos_trx.',vel_trx.',{'Radar'});

humanp = platformPlotter(tp,'Displayname','Human','Marker','*');
pos_human = pos{2};
vel_human = vel{2};
plotPlatform(humanp,pos_human.',vel_human.',{'Human'});

if numel(pos) == 3
    risp = platformPlotter(tp,'DisplayName','RIS','Marker','s','MarkerSize',20);
    pos_ris = pos{3};
    vel_ris = vel{3};
    plotPlatform(risp,pos_ris.',vel_ris.',{'RIS'});
end

trxcovp = coveragePlotter(tp,'DisplayName','Radar Coverage');
trxconfig = struct('Index',1,'LookAngle',[0;0],'ScanLimits',[0 90;0 20],'Range',200,'FieldOfView',[fov;0],...
    'Position',pos_trx.','Orientation',eye(3));
plotCoverage(trxcovp,trxconfig);

end