hardware accelerators for nr sib1 recovery -凯发k8网页登录

introduction

the simulink® models described in this example are fixed-point hdl optimized implementations of hardware accelerators for sib1 recovery for 5g nr. the example details three individual hardware accelerators that perform:

the sib1 grid recovery algorithm is designed and optimized for frequency range 1 (fr1). the coreset0 and sib1 ldpc decoding algorithms support both frequency ranges. the example shows how to integrate hardware accelerators with ssb detection and decoding designs to implement a complete sib1 recovery model. a design supporting both fr1 and fr2 is implemented in the example.

this example is one of a related set, for more information see .

file structure

this example uses these files.

simulink models

simulink data dictionary

matlab code

nr hdl sib1 demodulation

this figure shows the nrhdlsib1demodulation model. the top level of the model reads the signals from the matlab base workspace, passes them to the sib1 demodulation subsystem, and writes the outputs back to the workspace.

models.demodulationtop = 'nrhdlsib1demodulation';
open_system(models.demodulationtop);

sib1 demodulation subsystem

the sib1 demodulation subsystem references the nrhdlddcfr1core and nrhdlsib1demodulationfr1core models. the algorithm of the nrhdlsib1demodulationfr1core model is described in the next section. for details about the nrhdlddcfr1core model see the nr hdl cell search example. the output of the ddc is the input to the sib1 demodulation algorithm. the frequency offset applied to the ddc combines the ssb frequency offset estimation term, from a successful mib recovery, with the ssb to sib1 offset. the combined frequency offset centers coreset0 in the received waveform.

set_param([models.demodulationtop '/sib1 demodulation'],'open','on');

inputs

griddemodparambus

outputs

coreset0resourcesbus

coreset0occasionbus

mibbus

status signal states

sib1 demodulation model

this diagram shows the top level of the nrhdlsib1demodulationfr1core model. the design operates on iq data at 61.44 mhz sample rate and requires parameters from a successful mib recovery. the start signal begins a sib1 demodulation operation, set this signal to 1 when all input ports on the paramsin bus are valid. you must hold the values on paramsin constant for the duration of the demodulation.

models.demodulationcore = 'nrhdlsib1demodulationfr1core';
load_system(models.demodulationcore);
set_param(models.demodulationcore,'simulationcommand','update');
set_param([models.demodulationcore '/griddemodulationcore'],'open','on');

when the ofdm demod subsystem receives a start signal, it ofdm demodulates the input data and outputs the sib1 grid. the subsystem computes a variable size fft, with configurable cyclic prefix length and number of guard subcarriers. the fft size is selected depending on the subcarrier spacing of the sib1 grid. for scs 15 a 2048-point fft is used, and for scs 30 a 1024-point fft is used. these values correspond to the sample rate of 30.72 mhz. the cyclic prefix length varies during ofdm demodulation of the sib1 grid to account for the longer cyclic prefix symbols present at the halfsubframe boundaries. the number of guard subcarriers is used to extract the sib1 grid from the full demodulation bandwidth.

the ofdm demod subsystem requires configuration values to successfully demodulate the sib1 grid. these values are computed from the results of mib recovery. the configuration subsystem constructs the mib from the pbch payload and parses the pdcchsib1config field to determine coreset0resources and coreset0timingoccasion. the coreset0resources signal contains the frequency offset from the ssb to coreset0 and the bandwidth of the coreset0 resource grid. the coreset0timingoccasion signal contains the slot offset from the even sfn frame head to the first monitored slot i.e. the slot within 2 system frames. the monitored slot timing offset subsystem converts the coreset0timingoccasion slot offset to a timing reference count. the ssb pattern, ssb index, and ssb timing reference are used to compute the timing reference of the even sfn frame head, from which the timing reference value of coreset0 is computed. a timing reference counter, synchronized with the ssb detection references, is used to track the sib1 data stream. once the start signal is asserted, the startcontroller waits for the sib1 timing reference to reach the target offset computed by the monitored slot timing offset subsystem and then triggers the ofdm demodulation to begin. the diagram shows an example of the timing references for the monitored ssb, the even frame head, and the coreset0 timing occasion. these offsets depend on the configuration of the transmitting cell.

nr hdl coreset0 decoding

this figure shows the nrhdlcoreset0decoding model. the top level of the model reads the signals from the matlab base workspace, passes them to the coreset0 decoding subsystem, and writes the outputs back to the workspace.

models.coreset0top = 'nrhdlcoreset0decoding';
open_system(models.coreset0top);

coreset0 decoding subsystem

the coreset0 decoding subsystem references the nrhdlcoreset0decodingcore and nrhdlpolardecodingchaincore models. the algorithm of the nrhdlcoreset0decodingcore model is described in the next section. the nrhdlpolardecodingchaincore model is covered in the nr hdl mib recovery example. the subsystem performs channel estimation and equalization, qpsk symbol demodulation, descrambling, rate recovery, polar decoding, and crc decoding of coreset0 candidates. the design provides back pressure with the nextframe signal to indicate when it can accept a new candidate. the processing is split over two models to allow for the nrhdlpolardecodingchaincore to be shared between the ssb decoding and sib1 coreset0 decoding in the example. this section describes the inputs and outputs for the subsystem.

set_param([models.coreset0top '/coreset0 decoding'],'open','on');

inputs

outputs

status signal states

coreset0 decoding model

this diagram shows the top level of the nrhdlcoreset0decodingcore model. to decode coreset0 a blind search is performed over multiple candidates. the correct candidate is determined by the crc remainder equaling the sib1 rnti 65535. the design coordinates each search step and generates the required parameters to decode the candidate with the nrhdlpolardecodingchaincore model. after a candidate is decoded, the crc result is checked. if the crc passes, the decoded data is output on the dcidata port. if the crc fails, the algorithm signals with nextframe that it is ready for the next candidate. if all candidates are decoded with no success then searchfailed is set high. the number of search candidates per slot is determined from the searchspaces input, this signal is a vector of 3 values corresponding to the number of candidates for the three possible aggregation values [4 8 16]. the design expects candidates to be input in decreasing order of aggregation level. the total number of searches is twice the search spaces since two slots are monitored for decoding. the firstorsecondslot output signals which slot the dci was decoded in. the status signal can be used to monitor the progress of the decoding. each candidate failure is indicated by state 4 and the final result is signalled by either state 5 (failure) or state 6 (success).

models.coreset0decoding = 'nrhdlcoreset0decodingcore';
load_system(models.coreset0decoding);
set_param(models.coreset0decoding,'simulationcommand','update');
set_param(models.coreset0decoding,'open','on');

nr hdl sib1 ldpc decoding

this figure shows the nrhdlsib1lpdcdecoding model. the top level of the model reads the signals from the matlab base workspace, passes them to the sib1 ldpc decoding subsystem, and writes the outputs back to the workspace.

models.ldpctop = 'nrhdlsib1ldpcdecoding';
open_system(models.ldpctop);

sib1 ldpc decoding subsystem

the sib1 ldpc decoding subsystem references the nrhdlldpcdecodingchaincore model. the subsystem performs ldpc decoding, codeblock desegmentation, and crc decoding. this section describes the inputs and outputs for the subsystem.

set_param([models.ldpctop '/sib1 ldpc decoding'],'open','on');

inputs

outputs

status signal states

sib1 ldpc decoding model

this diagram shows the top level of the nrhdlldpcdecodingchaincore model. the design accepts input llrs along with a sample control bus and additional constants. the first stage performs ldpc rate recovery, this includes signal scaling and wordlength reduction to prepare the data for ldpc decoding. the second stage decodes the ldpc data using min-sum layered belief propagation with lifting factor from input port. for the sib1 use case only base graph 2 is supported so the bgn input is constant. the algorithm then performs codeblock desegmentation. for sib1 this only requires the removal of the padding bits from the end of the data to produce a length of tbs 16 crc bits. the final stage performs crc decoding using crc16 with no scrambling. the decoded sib1 bits and the error status are output. additionally, a status port is provided to show the algorithms progress. the output from the rate recovery stage is provided on the diagnostic port.

models.ldpcdecoding = 'nrhdlldpcdecodingchaincore';
load_system(models.ldpcdecoding);
set_param(models.ldpcdecoding,'simulationcommand','update');
set_param([models.ldpcdecoding '/ldpc decoding chain'],'open','on');

sib1 accelerators simulation setup

the diagram shows the simulation setup implemented by this example. 5g toolbox functions are used to generate a test waveform. matlab reference code is then used to perform the steps required for mib recovery - ssb search, demodulation, and decoding. the results provide the input data for the sib1 demodulation stage. the same input is passed to both matlab and simulink implementations of sib1 demodulation, and the output grids are directly compared. the coreset0 candidates are extracted from the grid and decoded using matlab and simulink. the dci result is used to extract the sib1 ldpc codeword from the resource grid and the final decode is performed in matlab and simulink. at each stage matlab and simulink results are compared to confirm their equivalence.

the test bench options section of the runsib1acceleratormodels script includes these variables to configure the simulation:

disp(nrhdlexamples.generatefr1rxwaveform('list'));

    simulation case    ssb pattern    subcarrier spacing common    pdcch config sib1    snr db    strongest ssb index    lmax
    _______________    ___________    _________________________    _________________    ______    ___________________    ____
      "simcase 1"       "case c"                 30                       164             50               4              8  
      "simcase 2"       "case b"                 15                       100              6               3              4  
      "simcase 3"       "case a"                 30                         4             20               2              8  
      "simcase 4"       "case a"                 15                        84              7               0              4  

sib1 accelerators simulation

use the runsib1acceleratormodels script to run a sib1 recovery simulation using the hardware accelerators. the script displays its progress at the matlab command prompt, and produces plots of inputs and outputs for analysis. this example shows the results of running "simcase 1". the resource grids produced by matlab and simulink from the sib1 demodulation are displayed along with the difference between them and their relative mean squared error (mse). the grid plots are labelled to highlight the decoded pdcch and pdsch. the dci fields from coreset0 decoding are displayed and the final sib1 bits are compared. this comparison verifies that the simulink implementations closely matches the matlab reference.

runsib1acceleratormodels;

runsib1acceleratormodels;

generating test waveform.
searching for ssbs using matlab reference.
demodulating the strongest ssb using matlab reference.
decoding the demodulated ssb using matlab reference.
demodulating the sib1 grid using matlab reference.
demodulating the sib1 grid using simulink model.
running nrhdlsib1demodulation.slx
### starting serial model reference simulation build.
### model reference simulation target for nrhdlddcfr1core is up to date.
### model reference simulation target for nrhdlsib1demodulationfr1core is up to date.
build summary
0 of 2 models built (2 models already up to date)
build duration: 0h 0m 1.1265s
..........
matlab and simulink grids relative mse : -62.7854 db
extracting coreset0 candidates from the sib1 grid.
decoding coreset0 candidates using matlab reference.
decoding coreset0 candidates using simulink.
running nrhdlcoreset0decoding.slx
### starting serial model reference simulation build.
### model reference simulation target for nrhdlcoreset0decodingcore is up to date.
### model reference simulation target for nrhdlpolardecodingchaincore is up to date.
build summary
0 of 2 models built (2 models already up to date)
build duration: 0h 0m 0.68171s
..........
dci from matlab:
                     riv: 528
                tddindex: 0
    vrbtoprbinterleaving: 0
               modcoding: 0
                      rv: 0
             siindicator: 0
                reserved: 0
dci from simulink:
                     riv: 528
                tddindex: 0
    vrbtoprbinterleaving: 0
               modcoding: 0
                      rv: 0
             siindicator: 0
                reserved: 0
dci successfully decoded from simulink grid with hardware acceleration
extracting ldpc codeword from the sib1 grid.
decoding sib1 using matlab reference.
decoding sib1 using simulink.
running nrhdlsib1ldpcdecoding.slx
### starting serial model reference simulation build.
### model reference simulation target for nrhdlldpcdecodingchaincore is up to date.
build summary
0 of 1 models built (1 models already up to date)
build duration: 0h 0m 0.57395s
..........
sib1 successfully decoded from simulink grid with hardware acceleration
sib1 bits from matlab and simulink match

hdl code generation and implementation results

to generate the hdl code for this example, you must have an hdl coder™ license. use the makehdl and makehdltb commands to generate hdl code and an hdl test bench for the nrhdlsib1demodulation/sib1 demodulation, nrhdlcoreset0decoding/coreset0 decoding or nrhdlsib1ldpcdecoding/sib1 ldpc decoding subsystems. the resulting hdl code was synthesized for a xilinx® zynq®-7000 zc706 evaluation board. the table shows the post place and route resource utilization results. the design meets timing with a clock frequency of 150 mhz.

resource utilization for nrhdlsib1demodulation model:

t = table(...
    categorical({'slice registers'; 'slice luts'; 'ramb18'; 'ramb36'; 'dsp48'}),...
    [13018; 7711; 18; 10; 35],...
    'variablenames',{'resource','usage'});
disp(t);

       resource        usage
    _______________    _____
    slice registers    13018
    slice luts          7711
    ramb18                18
    ramb36                10
    dsp48                 35

resource utilization for nrhdlcoreset0decoding model:

t = table(...
    categorical({'slice registers'; 'slice luts'; 'ramb18'; 'ramb36'; 'dsp48'}),...
    [8297; 11099; 8; 4; 16],...
    'variablenames',{'resource','usage'});
disp(t);

       resource        usage
    _______________    _____
    slice registers     8297
    slice luts         11099
    ramb18                 8
    ramb36                 4
    dsp48                 16

resource utilization for nrhdlsib1ldpcdecoding model:

t = table(...
    categorical({'slice registers'; 'slice luts'; 'ramb18'; 'ramb36'; 'dsp48'}),...
    [61827; 42120; 289; 20; 3],...
    'variablenames',{'resource','usage'});
disp(t);
fields = fieldnames(models);
for k=1:length(fields)
    close_system(models.(fields{k}),0);
end

       resource        usage
    _______________    _____
    slice registers    61827
    slice luts         42120
    ramb18               289
    ramb36                20
    dsp48                  3