mirror of https://github.com/pvnis/srsRAN_4G.git
Working on mac_test
ismagom
10 years ago
parent
881a90d62c
commit
68d193a725
@ -1,12 +1,18 @@
|
||||
function cfo = cfo_estimate_cp(input, Nsyms, sym_len, cp0_len, cp_len)
|
||||
function cfo = cfo_estimate_cp(input_slot, Nsyms, sym_len, cp0_len, cp_len)
|
||||
|
||||
r=zeros(Nsyms, 1);
|
||||
r(1)=sum(input(1:cp0_len).*conj(input(1+sym_len:cp0_len+sym_len)));
|
||||
s=cp0_len+sym_len+1;
|
||||
e=cp0_len+sym_len+cp_len;
|
||||
for i=2:Nsyms
|
||||
r(i)=sum(input(s:e).*conj(input(s+sym_len:e+sym_len)));
|
||||
s=s+sym_len+cp_len;
|
||||
e=e+sym_len+cp_len;
|
||||
% Start correlating from the end. Nsyms is the number of symbols to
|
||||
% correlate starting from the end.
|
||||
|
||||
s=length(input_slot)-sym_len-cp_len;
|
||||
e=length(input_slot)-sym_len;
|
||||
for i=1:Nsyms
|
||||
r(i)=sum(input_slot(s:e).*conj(input_slot(s+sym_len:e+sym_len)));
|
||||
if (i < 7)
|
||||
s=s-sym_len-cp_len;
|
||||
e=e-sym_len-cp_len;
|
||||
else
|
||||
s=s-sym_len-cp0_len;
|
||||
e=e-sym_len-cp0_len;
|
||||
end
|
||||
end
|
||||
cfo=-angle(mean(r))/2/pi;
|
||||
cfo=-angle(mean(r))/pi;
|
||||
@ -1,27 +1,21 @@
|
||||
%clear;
|
||||
M=1000;
|
||||
clear;
|
||||
sym_len=128;
|
||||
x=lte(1:M*15360*sym_len/2048*2000/1536);
|
||||
%x=read_complex('../../../eclipse_osldlib/test.dat');
|
||||
%y=resample(x,99839996,100000000);
|
||||
|
||||
input=resample(x,1536,2000);
|
||||
%input=x;
|
||||
%input=y(1:M*15360*sym_len/2048);
|
||||
%input=resample(x,3840000,1920000);
|
||||
hflen = (sym_len/128)*1920*10;
|
||||
N_id_2=1;
|
||||
input=read_complex('../../build/lte_signal.dat', hflen*500);
|
||||
|
||||
cp0_len=160*sym_len/2048;
|
||||
cp1_len=144*sym_len/2048;
|
||||
|
||||
slots=reshape(input,15360*sym_len/2048,[]);
|
||||
[n m]=size(slots);
|
||||
subframes=reshape(input,hflen,[]);
|
||||
[n m]=size(subframes);
|
||||
|
||||
cfo=zeros(m,1);
|
||||
output=zeros(size(input));
|
||||
cfo=zeros(m,2);
|
||||
for i=1:m
|
||||
cfo(i)=cfo_estimate(slots(:,i),7,sym_len,cp1_len,cp1_len);
|
||||
t=(i-1)*n+1:i*n;
|
||||
%output(t)=input(t).*exp(-1i*2*pi*cfo(i)*t/sym_len);
|
||||
cfo(i,1) = cfo_estimate_cp(subframes(1:960,i),1,sym_len,cp0_len,cp1_len);
|
||||
[~, cfo(i,2)] = find_pss(subframes(:,i),N_id_2);
|
||||
|
||||
end
|
||||
|
||||
plot(cfo)
|
||||
legend('CP-based','PSS-based')
|
||||
@ -1,55 +0,0 @@
|
||||
function [ s0_m0 z1_m0 ] = compute_m0( m0)
|
||||
%COMPUTE_S Summary of this function goes here
|
||||
% Detailed explanation goes here
|
||||
|
||||
% Generate s_tilda
|
||||
x_s_tilda(0+1) = 0;
|
||||
x_s_tilda(1+1) = 0;
|
||||
x_s_tilda(2+1) = 0;
|
||||
x_s_tilda(3+1) = 0;
|
||||
x_s_tilda(4+1) = 1;
|
||||
for(i_hat=0:25)
|
||||
x_s_tilda(i_hat+5+1) = mod((x_s_tilda(i_hat+2+1) + x_s_tilda(i_hat+1)), 2);
|
||||
end
|
||||
for(idx=0:30)
|
||||
s_tilda(idx+1) = 1 - 2*x_s_tilda(idx+1);
|
||||
end
|
||||
|
||||
% Generate c_tilda
|
||||
x_c_tilda(0+1) = 0;
|
||||
x_c_tilda(1+1) = 0;
|
||||
x_c_tilda(2+1) = 0;
|
||||
x_c_tilda(3+1) = 0;
|
||||
x_c_tilda(4+1) = 1;
|
||||
for(i_hat=0:25)
|
||||
x_c_tilda(i_hat+5+1) = mod((x_c_tilda(i_hat+3+1) + x_c_tilda(i_hat+1)), 2);
|
||||
end
|
||||
for(idx=0:30)
|
||||
c_tilda(idx+1) = 1 - 2*x_c_tilda(idx+1);
|
||||
end
|
||||
|
||||
% Generate z_tilda
|
||||
x_z_tilda(0+1) = 0;
|
||||
x_z_tilda(1+1) = 0;
|
||||
x_z_tilda(2+1) = 0;
|
||||
x_z_tilda(3+1) = 0;
|
||||
x_z_tilda(4+1) = 1;
|
||||
for(i_hat=0:25)
|
||||
x_z_tilda(i_hat+5+1) = mod((x_z_tilda(i_hat+4+1) + x_z_tilda(i_hat+2+1) + x_z_tilda(i_hat+1+1) + x_z_tilda(i_hat+1)), 2);
|
||||
end
|
||||
for(idx=0:30)
|
||||
z_tilda(idx+1) = 1 - 2*x_z_tilda(idx+1);
|
||||
end
|
||||
|
||||
% Generate s0_m0 and s1_m1
|
||||
for(n=0:30)
|
||||
s0_m0(n+1) = s_tilda(mod(n + m0, 31)+1);
|
||||
end
|
||||
|
||||
% Generate z1_m0 and z1_m1
|
||||
for(n=0:30)
|
||||
z1_m0(n+1) = z_tilda(mod(n + mod(m0, 8), 31)+1);
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@ -1,49 +0,0 @@
|
||||
function [ s1_m1 ] = compute_m1( m1, N_id_2)
|
||||
%COMPUTE_S Summary of this function goes here
|
||||
% Detailed explanation goes here
|
||||
|
||||
% Generate s_tilda
|
||||
x_s_tilda(0+1) = 0;
|
||||
x_s_tilda(1+1) = 0;
|
||||
x_s_tilda(2+1) = 0;
|
||||
x_s_tilda(3+1) = 0;
|
||||
x_s_tilda(4+1) = 1;
|
||||
for(i_hat=0:25)
|
||||
x_s_tilda(i_hat+5+1) = mod((x_s_tilda(i_hat+2+1) + x_s_tilda(i_hat+1)), 2);
|
||||
end
|
||||
for(idx=0:30)
|
||||
s_tilda(idx+1) = 1 - 2*x_s_tilda(idx+1);
|
||||
end
|
||||
|
||||
% Generate c_tilda
|
||||
x_c_tilda(0+1) = 0;
|
||||
x_c_tilda(1+1) = 0;
|
||||
x_c_tilda(2+1) = 0;
|
||||
x_c_tilda(3+1) = 0;
|
||||
x_c_tilda(4+1) = 1;
|
||||
for(i_hat=0:25)
|
||||
x_c_tilda(i_hat+5+1) = mod((x_c_tilda(i_hat+3+1) + x_c_tilda(i_hat+1)), 2);
|
||||
end
|
||||
for(idx=0:30)
|
||||
c_tilda(idx+1) = 1 - 2*x_c_tilda(idx+1);
|
||||
end
|
||||
|
||||
% Generate z_tilda
|
||||
x_z_tilda(0+1) = 0;
|
||||
x_z_tilda(1+1) = 0;
|
||||
x_z_tilda(2+1) = 0;
|
||||
x_z_tilda(3+1) = 0;
|
||||
x_z_tilda(4+1) = 1;
|
||||
for(i_hat=0:25)
|
||||
x_z_tilda(i_hat+5+1) = mod((x_z_tilda(i_hat+4+1) + x_z_tilda(i_hat+2+1) + x_z_tilda(i_hat+1+1) + x_z_tilda(i_hat+1)), 2);
|
||||
end
|
||||
for(idx=0:30)
|
||||
z_tilda(idx+1) = 1 - 2*x_z_tilda(idx+1);
|
||||
end
|
||||
|
||||
% Generate s0_m0 and s1_m1
|
||||
for(n=0:30)
|
||||
s1_m1(n+1) = s_tilda(mod(n + m1, 31)+1);
|
||||
end
|
||||
end
|
||||
|
||||
@ -1,57 +0,0 @@
|
||||
function [out] = convfft(z1,z2)
|
||||
%CONVFFT FFT-based convolution and polynomial multiplication.
|
||||
% C = CONVFFT(A, B) convolves vectors A and B. The resulting
|
||||
% vector is length LENGTH(A)+LENGTH(B)-1.
|
||||
% If A and B are vectors of polynomial coefficients, convolving
|
||||
% them is equivalent to multiplying the two polynomials.
|
||||
%
|
||||
% Please contribute if you find this software useful.
|
||||
% Report bugs to luigi.rosa@tiscali.it
|
||||
%
|
||||
%*****************************************************************
|
||||
% Luigi Rosa
|
||||
% Via Centrale 27
|
||||
% 67042 Civita di Bagno
|
||||
% L'Aquila --- ITALY
|
||||
% email luigi.rosa@tiscali.it
|
||||
% mobile +39 340 3463208
|
||||
% http://utenti.lycos.it/matlab
|
||||
%*****************************************************************
|
||||
%
|
||||
|
||||
|
||||
z1x=size(z1,1);
|
||||
z1y=size(z1,2);
|
||||
z2x=size(z2,1);
|
||||
z2y=size(z2,2);
|
||||
if (~isa(z1,'double'))||(~isa(z2,'double'))||(ndims(z1)>2)||(ndims(z2)>2)
|
||||
disp('Error: input vector must be unidimensional double array');
|
||||
out=[];
|
||||
return;
|
||||
else
|
||||
if ((z1x>1)&&(z1y>1)) || ((z2x>1)&&(z2y>1))
|
||||
out=[];
|
||||
disp('Error: input vectors are double matrices');
|
||||
return;
|
||||
|
||||
else
|
||||
|
||||
if (z1x==1)&&(z1y>1)
|
||||
z1=z1';
|
||||
z1x=z1y;
|
||||
end
|
||||
|
||||
|
||||
if (z2x==1)&&(z2y>1)
|
||||
z2=z2';
|
||||
z2x=z2y;
|
||||
end
|
||||
|
||||
|
||||
if (any(any(imag(z1))))||(any(any(imag(z2))))
|
||||
out=(ifft(fft(z1,z1x+z2x-1).*fft(z2,z1x+z2x-1)));
|
||||
else
|
||||
out=real(ifft(fft(z1,z1x+z2x-1).*fft(z2,z1x+z2x-1)));
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -1,82 +0,0 @@
|
||||
function [coarse_start freq_offset] = find_coarse_time_and_freq_offset(in, N_cp_l_else)
|
||||
|
||||
% Decompose input
|
||||
in_re = real(in);
|
||||
in_im = imag(in);
|
||||
|
||||
abs_corr = zeros(1,960);
|
||||
for(slot=0:10)
|
||||
for(n=1:40:960)
|
||||
corr_re = 0;
|
||||
corr_im = 0;
|
||||
for(z=1:N_cp_l_else)
|
||||
index = (slot*960) + n-1 + z;
|
||||
corr_re = corr_re + in_re(index)*in_re(index+128) + in_im(index)*in_im(index+128);
|
||||
corr_im = corr_im + in_re(index)*in_im(index+128) - in_im(index)*in_re(index+128);
|
||||
end
|
||||
abs_corr(n) = abs_corr(n) + corr_re*corr_re + corr_im*corr_im;
|
||||
end
|
||||
end
|
||||
|
||||
% Find first and second max
|
||||
abs_corr_idx = zeros(1,2);
|
||||
for(m=0:1)
|
||||
abs_corr_max = 0;
|
||||
for(n=1:480)
|
||||
if(abs_corr((m*480)+n) > abs_corr_max)
|
||||
abs_corr_max = abs_corr((m*480)+n);
|
||||
abs_corr_idx(m+1) = (m*480)+n;
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
% Fine correlation and fraction frequency offset
|
||||
abs_corr = zeros(1,960);
|
||||
corr_freq_err = zeros(1,960);
|
||||
for(slot=1:10)
|
||||
for(idx=1:2)
|
||||
if((abs_corr_idx(idx) - 40) < 1)
|
||||
abs_corr_idx(idx) = 41;
|
||||
end
|
||||
if((abs_corr_idx(idx) + 40) > 960)
|
||||
abs_corr_idx(idx) = 960 - 40;
|
||||
end
|
||||
for(n=abs_corr_idx(idx)-40:abs_corr_idx(idx)+40)
|
||||
corr_re = 0;
|
||||
corr_im = 0;
|
||||
for(z=1:N_cp_l_else)
|
||||
index = (slot*960) + n-1 + z;
|
||||
corr_re = corr_re + in_re(index)*in_re(index+128) + in_im(index)*in_im(index+128);
|
||||
corr_im = corr_im + in_re(index)*in_im(index+128) - in_im(index)*in_re(index+128);
|
||||
end
|
||||
abs_corr(n) = abs_corr(n) + corr_re*corr_re + corr_im*corr_im;
|
||||
corr_freq_err(n) = corr_freq_err(n) + atan2(corr_im, corr_re)/(128*2*pi*(0.0005/960));
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
% Find first and second max
|
||||
abs_corr_idx = zeros(1,2);
|
||||
for(m=0:1)
|
||||
abs_corr_max = 0;
|
||||
for(n=1:480)
|
||||
if(abs_corr((m*480)+n) > abs_corr_max)
|
||||
abs_corr_max = abs_corr((m*480)+n);
|
||||
abs_corr_idx(m+1) = (m*480)+n;
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
% Determine frequency offset FIXME No integer offset is calculated here
|
||||
freq_offset = (corr_freq_err(abs_corr_idx(1))/10 + corr_freq_err(abs_corr_idx(2))/10)/2;23
|
||||
|
||||
% Determine the symbol start locations from the correlation peaks
|
||||
% FIXME Needs some work
|
||||
tmp = abs_corr_idx(1);
|
||||
while(tmp > 0)
|
||||
tmp = tmp - 2192;
|
||||
end
|
||||
for(n=1:7)
|
||||
coarse_start(n) = tmp + (n*2192);
|
||||
end
|
||||
end
|
||||
@ -1,31 +1,18 @@
|
||||
function [ fs eps p_m w2] = find_pss( x, N_id_2, doplot, threshold)
|
||||
if nargin == 2
|
||||
doplot = false;
|
||||
threshold = 0;
|
||||
end
|
||||
if nargin == 3
|
||||
threshold = 0;
|
||||
end
|
||||
function [ fs, cfo, p_m, w2] = find_pss( x, N_id_2)
|
||||
|
||||
c=lte_pss_zc(N_id_2);
|
||||
cc=[zeros(33,1); c; zeros(33,1)];
|
||||
ccf=[0; cc(65:128); cc(2:64)];
|
||||
ccf=conj(ifft(ccf));
|
||||
|
||||
w2=conv(x,ccf);
|
||||
if (doplot)
|
||||
%plot(10*log10(abs(w2)));%./mean(abs(w2))));
|
||||
plot(abs(w2))
|
||||
%axis([0 length(w2) 0 20])
|
||||
end
|
||||
[m i]=max(abs(w2));
|
||||
fs=i-960;
|
||||
p_m = m/mean(abs(w2));
|
||||
|
||||
if doplot
|
||||
fprintf('Frame starts at %d, m=%g, p=%g, p/m=%g dB\n',fs, ...
|
||||
mean(abs(w2)), m, 10*log10(m/mean(abs(w2))));
|
||||
end
|
||||
[m, fs]=max(abs(w2));
|
||||
|
||||
y=ccf.*x(fs-128:fs-1);
|
||||
y0=y(1:64);
|
||||
y1=y(65:length(y));
|
||||
|
||||
cfo=angle(conj(sum(y0))*sum(y1))/pi;
|
||||
p_m = m/mean(abs(w2));
|
||||
|
||||
end
|
||||
|
||||
|
||||
@ -1,165 +0,0 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 The srsLTE Developers. See the
|
||||
* COPYRIGHT file at the top-level directory of this distribution.
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsLTE library.
|
||||
*
|
||||
* srsLTE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsLTE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#include <stdint.h>
|
||||
#include "srsapps/common/log.h"
|
||||
|
||||
#ifndef MACPDU_H
|
||||
#define MACPDU_H
|
||||
|
||||
/* MAC PDU Packing/Unpacking functions */
|
||||
|
||||
namespace srslte {
|
||||
namespace ue {
|
||||
|
||||
class mac_pdu
|
||||
{
|
||||
public:
|
||||
|
||||
class mac_subh
|
||||
{
|
||||
public:
|
||||
|
||||
typedef enum {
|
||||
C_RNTI = 0,
|
||||
CON_RES_ID,
|
||||
TA_CMD,
|
||||
PHD,
|
||||
SDU
|
||||
} cetype;
|
||||
|
||||
// Reading functions
|
||||
bool is_sdu();
|
||||
cetype ce_type();
|
||||
|
||||
uint32_t get_sdu_lcid();
|
||||
uint32_t get_sdu_nbytes();
|
||||
uint8_t* get_sdu_ptr();
|
||||
|
||||
uint16_t get_c_rnti();
|
||||
uint64_t get_con_res_id();
|
||||
uint8_t get_ta_cmd();
|
||||
uint8_t get_phd();
|
||||
|
||||
// Writing functions
|
||||
bool set_sdu(uint8_t *ptr, uint32_t nof_bytes);
|
||||
bool set_c_rnti(uint16_t crnti);
|
||||
bool set_con_res_id(uint64_t con_res_id);
|
||||
bool set_ta_cmd(uint8_t ta_cmd);
|
||||
bool set_phd(uint8_t phd);
|
||||
|
||||
private:
|
||||
static const int MAX_CE_PAYLOAD_LEN = 8;
|
||||
uint32_t lcid;
|
||||
uint32_t nof_bytes;
|
||||
uint8_t* sdu_payload_ptr;
|
||||
uint8_t ce_payload[MAX_CE_PAYLOAD_LEN];
|
||||
};
|
||||
|
||||
mac_pdu(uint32_t max_subheaders);
|
||||
|
||||
void reset();
|
||||
void init(uint32_t pdu_len);
|
||||
|
||||
bool read_next();
|
||||
bool write_next();
|
||||
mac_subh* get();
|
||||
|
||||
bool write_packet(uint8_t *ptr);
|
||||
void parse_packet(uint8_t *ptr);
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
mac_subh *subheaders;
|
||||
uint32_t pdu_len;
|
||||
uint32_t rem_len;
|
||||
uint32_t rp, wp;
|
||||
uint32_t nof_subheaders;
|
||||
uint32_t max_subheaders;
|
||||
};
|
||||
|
||||
class mac_rar_pdu
|
||||
{
|
||||
public:
|
||||
class mac_rar
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
static const uint32_t RAR_GRANT_LEN = 20;
|
||||
|
||||
// Reading functions
|
||||
uint32_t get_rapid();
|
||||
uint32_t get_ta_cmd();
|
||||
uint16_t get_temp_crnti();
|
||||
void get_sched_grant(uint8_t grant[RAR_GRANT_LEN]);
|
||||
|
||||
// Writing functoins
|
||||
void set_rapid(uint32_t rapid);
|
||||
void set_ta_cmd(uint32_t ta);
|
||||
void set_temp_crnti(uint16_t temp_rnti);
|
||||
void set_sched_grant(uint8_t grant[RAR_GRANT_LEN]);
|
||||
private:
|
||||
uint8_t grant[RAR_GRANT_LEN];
|
||||
uint32_t ta;
|
||||
uint16_t temp_rnti;
|
||||
};
|
||||
|
||||
mac_rar_pdu(uint32_t max_rars);
|
||||
|
||||
void reset();
|
||||
void init(uint32_t pdu_len);
|
||||
|
||||
bool read_next();
|
||||
bool write_next();
|
||||
mac_rar* get();
|
||||
|
||||
void set_backoff(uint8_t bi);
|
||||
bool is_backoff();
|
||||
uint8_t get_backoff();
|
||||
|
||||
bool write_packet(uint8_t *ptr);
|
||||
void parse_packet(uint8_t *ptr);
|
||||
|
||||
|
||||
private:
|
||||
mac_rar *rars;
|
||||
uint32_t pdu_len;
|
||||
uint32_t rem_len;
|
||||
uint32_t rp, wp;
|
||||
uint32_t nof_rars;
|
||||
uint32_t max_rars;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -0,0 +1,285 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 The srsLTE Developers. See the
|
||||
* COPYRIGHT file at the top-level directory of this distribution.
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsLTE library.
|
||||
*
|
||||
* srsLTE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsLTE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#include <stdint.h>
|
||||
#include "srsapps/common/log.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
#ifndef MACPDU_H
|
||||
#define MACPDU_H
|
||||
|
||||
/* MAC PDU Packing/Unpacking functions. Section 6 of 36.321 */
|
||||
|
||||
namespace srslte {
|
||||
namespace ue {
|
||||
|
||||
|
||||
template<class SubH>
|
||||
class pdu
|
||||
{
|
||||
public:
|
||||
|
||||
pdu(uint32_t max_subheaders_) : subheaders(max_subheaders_) {
|
||||
max_subheaders = max_subheaders_;
|
||||
nof_subheaders = 0;
|
||||
cur_idx = -1;
|
||||
pdu_len = 0;
|
||||
rem_len = 0;
|
||||
for (int i=0;i<max_subheaders;i++) {
|
||||
subheaders[i].parent = this;
|
||||
}
|
||||
}
|
||||
|
||||
void fprint(FILE *stream) {
|
||||
fprintf(stream, "Number of Subheaders: %d\n", nof_subheaders);
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
fprintf(stream, " -- Subheader %d: ", i);
|
||||
subheaders[i].fprint(stream);
|
||||
}
|
||||
}
|
||||
|
||||
/* Resets the Read/Write position and remaining PDU length */
|
||||
void reset() {
|
||||
cur_idx = -1;
|
||||
rem_len = pdu_len;
|
||||
}
|
||||
|
||||
/* Prepares the PDU for parsing or writing by setting the number of subheaders to 0 and the pdu length */
|
||||
void init(uint32_t pdu_len_bytes) {
|
||||
init(pdu_len_bytes, false);
|
||||
}
|
||||
void init(uint32_t pdu_len_bytes, bool is_ulsch) {
|
||||
nof_subheaders = 0;
|
||||
pdu_len = pdu_len_bytes;
|
||||
rem_len = pdu_len;
|
||||
pdu_is_ul = is_ulsch;
|
||||
reset();
|
||||
for (int i=0;i<max_subheaders;i++) {
|
||||
subheaders[i].init();
|
||||
}
|
||||
}
|
||||
|
||||
bool new_subh() {
|
||||
if (nof_subheaders < max_subheaders - 1) {
|
||||
nof_subheaders++;
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool next() {
|
||||
if (cur_idx < nof_subheaders - 1) {
|
||||
cur_idx++;
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
SubH* get() {
|
||||
if (cur_idx >= 0) {
|
||||
return &subheaders[cur_idx];
|
||||
}
|
||||
}
|
||||
|
||||
// Section 6.1.2
|
||||
void parse_packet(uint8_t *ptr) {
|
||||
nof_subheaders = 0;
|
||||
while(subheaders[nof_subheaders].read_subheader(&ptr)) {
|
||||
nof_subheaders++;
|
||||
}
|
||||
nof_subheaders++;
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
subheaders[i].read_payload(&ptr);
|
||||
}
|
||||
}
|
||||
bool is_ul() {
|
||||
return pdu_is_ul;
|
||||
}
|
||||
|
||||
virtual bool write_packet(uint8_t *ptr) = 0;
|
||||
|
||||
protected:
|
||||
std::vector<SubH> subheaders;
|
||||
uint32_t pdu_len;
|
||||
uint32_t rem_len;
|
||||
int cur_idx;
|
||||
int nof_subheaders;
|
||||
uint32_t max_subheaders;
|
||||
bool pdu_is_ul;
|
||||
};
|
||||
|
||||
template<class SubH>
|
||||
class subh
|
||||
{
|
||||
public:
|
||||
|
||||
virtual bool read_subheader(uint8_t** ptr) = 0;
|
||||
virtual void read_payload(uint8_t **ptr) = 0;
|
||||
virtual void write_subheader(uint8_t** ptr, bool is_last) = 0;
|
||||
virtual void write_payload(uint8_t **ptr) = 0;
|
||||
virtual void fprint(FILE *stream) = 0;
|
||||
|
||||
pdu<SubH>* parent;
|
||||
|
||||
private:
|
||||
virtual void init() = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
class sch_subh : public subh<sch_subh>
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
typedef enum {
|
||||
PHD_REPORT = 26,
|
||||
C_RNTI = 27,
|
||||
CON_RES_ID = 28,
|
||||
TRUNC_BSR = 28,
|
||||
TA_CMD = 29,
|
||||
SHORT_BSR = 29,
|
||||
DRX_CMD = 30,
|
||||
LONG_BSR = 30,
|
||||
PADDING = 31,
|
||||
SDU = 0
|
||||
} cetype;
|
||||
|
||||
// Reading functions
|
||||
bool is_sdu();
|
||||
cetype ce_type();
|
||||
|
||||
bool read_subheader(uint8_t** ptr);
|
||||
void read_payload(uint8_t **ptr);
|
||||
uint32_t get_sdu_lcid();
|
||||
uint32_t get_sdu_nbytes();
|
||||
uint8_t* get_sdu_ptr();
|
||||
|
||||
uint16_t get_c_rnti();
|
||||
uint64_t get_con_res_id();
|
||||
uint8_t get_ta_cmd();
|
||||
uint8_t get_phd();
|
||||
|
||||
// Writing functions
|
||||
void write_subheader(uint8_t** ptr, bool is_last);
|
||||
void write_payload(uint8_t **ptr);
|
||||
bool set_sdu(uint32_t lcid, uint8_t *ptr, uint32_t nof_bytes);
|
||||
bool set_c_rnti(uint16_t crnti);
|
||||
bool set_con_res_id(uint64_t con_res_id);
|
||||
bool set_ta_cmd(uint8_t ta_cmd);
|
||||
bool set_phd(uint8_t phd);
|
||||
void set_padding();
|
||||
|
||||
void init();
|
||||
void fprint(FILE *stream);
|
||||
|
||||
private:
|
||||
static const int MAX_CE_PAYLOAD_LEN = 8;
|
||||
uint32_t lcid;
|
||||
uint32_t nof_bytes;
|
||||
uint8_t* sdu_payload_ptr;
|
||||
bool F_bit;
|
||||
uint8_t ce_payload[MAX_CE_PAYLOAD_LEN];
|
||||
uint32_t sizeof_ce(uint32_t lcid, bool is_ul);
|
||||
};
|
||||
|
||||
class sch_pdu : public pdu<sch_subh>
|
||||
{
|
||||
public:
|
||||
|
||||
sch_pdu(uint32_t max_rars) : pdu(max_rars) {}
|
||||
|
||||
bool write_packet(uint8_t *ptr);
|
||||
bool has_space_ce(uint32_t nbytes);
|
||||
bool has_space_sdu(uint32_t nbytes);
|
||||
static uint32_t size_plus_header_pdu(uint32_t nbytes);
|
||||
bool update_space_ce(uint32_t nbytes);
|
||||
bool update_space_sdu(uint32_t nbytes);
|
||||
void fprint(FILE *stream);
|
||||
|
||||
};
|
||||
|
||||
class rar_subh : public subh<rar_subh>
|
||||
{
|
||||
public:
|
||||
|
||||
static const uint32_t RAR_GRANT_LEN = 20;
|
||||
|
||||
// Reading functions
|
||||
bool read_subheader(uint8_t** ptr);
|
||||
void read_payload(uint8_t** ptr);
|
||||
uint32_t get_rapid();
|
||||
uint32_t get_ta_cmd();
|
||||
uint16_t get_temp_crnti();
|
||||
void get_sched_grant(uint8_t grant[RAR_GRANT_LEN]);
|
||||
|
||||
// Writing functoins
|
||||
void write_subheader(uint8_t** ptr, bool is_last);
|
||||
void write_payload(uint8_t** ptr);
|
||||
void set_rapid(uint32_t rapid);
|
||||
void set_ta_cmd(uint32_t ta);
|
||||
void set_temp_crnti(uint16_t temp_rnti);
|
||||
void set_sched_grant(uint8_t grant[RAR_GRANT_LEN]);
|
||||
|
||||
void init();
|
||||
void fprint(FILE *stream);
|
||||
|
||||
private:
|
||||
uint8_t grant[RAR_GRANT_LEN];
|
||||
uint32_t ta;
|
||||
uint16_t temp_rnti;
|
||||
uint32_t preamble;
|
||||
};
|
||||
|
||||
class rar_pdu : public pdu<rar_subh>
|
||||
{
|
||||
public:
|
||||
|
||||
rar_pdu(uint32_t max_rars);
|
||||
|
||||
void set_backoff(uint8_t bi);
|
||||
bool has_backoff();
|
||||
uint8_t get_backoff();
|
||||
|
||||
bool write_packet(uint8_t* ptr);
|
||||
void fprint(FILE *stream);
|
||||
|
||||
private:
|
||||
bool has_backoff_indicator;
|
||||
uint8_t backoff_indicator;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,214 +0,0 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 The srsLTE Developers. See the
|
||||
* COPYRIGHT file at the top-level directory of this distribution.
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsLTE library.
|
||||
*
|
||||
* srsLTE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsLTE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "srsapps/ue/mac/mac_pdu.h"
|
||||
|
||||
namespace srslte {
|
||||
namespace ue {
|
||||
mac_pdu::mac_subh* mac_pdu::get()
|
||||
{
|
||||
|
||||
}
|
||||
void mac_pdu::init(uint32_t pdu_len)
|
||||
{
|
||||
|
||||
}
|
||||
mac_pdu::mac_pdu(uint32_t max_subheaders)
|
||||
{
|
||||
|
||||
}
|
||||
mac_pdu::mac_subh::cetype mac_pdu::mac_subh::ce_type()
|
||||
{
|
||||
|
||||
}
|
||||
uint16_t mac_pdu::mac_subh::get_c_rnti()
|
||||
{
|
||||
|
||||
}
|
||||
uint64_t mac_pdu::mac_subh::get_con_res_id()
|
||||
{
|
||||
|
||||
}
|
||||
uint8_t mac_pdu::mac_subh::get_phd()
|
||||
{
|
||||
|
||||
}
|
||||
uint32_t mac_pdu::mac_subh::get_sdu_lcid()
|
||||
{
|
||||
|
||||
}
|
||||
uint32_t mac_pdu::mac_subh::get_sdu_nbytes()
|
||||
{
|
||||
|
||||
}
|
||||
uint8_t* mac_pdu::mac_subh::get_sdu_ptr()
|
||||
{
|
||||
|
||||
}
|
||||
uint8_t mac_pdu::mac_subh::get_ta_cmd()
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_pdu::mac_subh::is_sdu()
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_pdu::mac_subh::set_c_rnti(uint16_t crnti)
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_pdu::mac_subh::set_con_res_id(uint64_t con_res_id)
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_pdu::mac_subh::set_phd(uint8_t phd)
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_pdu::mac_subh::set_sdu(uint8_t* ptr, uint32_t nof_bytes)
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_pdu::mac_subh::set_ta_cmd(uint8_t ta_cmd)
|
||||
{
|
||||
|
||||
}
|
||||
void mac_pdu::parse_packet(uint8_t* ptr)
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_pdu::read_next()
|
||||
{
|
||||
|
||||
}
|
||||
void mac_pdu::reset()
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_pdu::write_next()
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_pdu::write_packet(uint8_t* ptr)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
mac_rar_pdu::mac_rar* mac_rar_pdu::get()
|
||||
{
|
||||
|
||||
}
|
||||
uint8_t mac_rar_pdu::get_backoff()
|
||||
{
|
||||
|
||||
}
|
||||
void mac_rar_pdu::init(uint32_t pdu_len)
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_rar_pdu::is_backoff()
|
||||
{
|
||||
|
||||
}
|
||||
uint32_t mac_rar_pdu::mac_rar::get_rapid()
|
||||
{
|
||||
|
||||
}
|
||||
void mac_rar_pdu::mac_rar::get_sched_grant(uint8_t grant[])
|
||||
{
|
||||
|
||||
}
|
||||
uint32_t mac_rar_pdu::mac_rar::get_ta_cmd()
|
||||
{
|
||||
|
||||
}
|
||||
uint16_t mac_rar_pdu::mac_rar::get_temp_crnti()
|
||||
{
|
||||
|
||||
}
|
||||
void mac_rar_pdu::mac_rar::set_rapid(uint32_t rapid)
|
||||
{
|
||||
|
||||
}
|
||||
void mac_rar_pdu::mac_rar::set_sched_grant(uint8_t grant[])
|
||||
{
|
||||
|
||||
}
|
||||
void mac_rar_pdu::mac_rar::set_ta_cmd(uint32_t ta)
|
||||
{
|
||||
|
||||
}
|
||||
void mac_rar_pdu::mac_rar::set_temp_crnti(uint16_t temp_rnti)
|
||||
{
|
||||
|
||||
}
|
||||
mac_rar_pdu::mac_rar_pdu(uint32_t max_rars)
|
||||
{
|
||||
|
||||
}
|
||||
void mac_rar_pdu::parse_packet(uint8_t* ptr)
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_rar_pdu::read_next()
|
||||
{
|
||||
|
||||
}
|
||||
void mac_rar_pdu::reset()
|
||||
{
|
||||
|
||||
}
|
||||
void mac_rar_pdu::set_backoff(uint8_t bi)
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_rar_pdu::write_next()
|
||||
{
|
||||
|
||||
}
|
||||
bool mac_rar_pdu::write_packet(uint8_t* ptr)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef kk
|
||||
bool demux::lcid_is_lch(uint32_t lcid) {
|
||||
if (lcid <= LIBLTE_MAC_DLSCH_DCCH_LCID_END) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,497 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 The srsLTE Developers. See the
|
||||
* COPYRIGHT file at the top-level directory of this distribution.
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsLTE library.
|
||||
*
|
||||
* srsLTE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsLTE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <strings.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "srsapps/ue/mac/pdu.h"
|
||||
#include "srslte/srslte.h"
|
||||
|
||||
namespace srslte {
|
||||
namespace ue {
|
||||
|
||||
|
||||
void sch_pdu::fprint(FILE* stream)
|
||||
{
|
||||
fprintf(stream, "MAC SDU for UL/DL-SCH. ");
|
||||
pdu::fprint(stream);
|
||||
}
|
||||
|
||||
void sch_subh::fprint(FILE* stream)
|
||||
{
|
||||
if (is_sdu()) {
|
||||
fprintf(stream, "SDU LCHID=%d, SDU nof_bytes=%d\n", lcid, nof_bytes);
|
||||
} else {
|
||||
switch(lcid) {
|
||||
case C_RNTI:
|
||||
fprintf(stream, "C-RNTI CE: %d\n", get_c_rnti());
|
||||
break;
|
||||
case CON_RES_ID:
|
||||
fprintf(stream, "Contention Resolution ID CE: %d\n", get_con_res_id());
|
||||
break;
|
||||
case TA_CMD:
|
||||
fprintf(stream, "Time Advance Command CE: %d\n", get_ta_cmd());
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Section 6.1.2
|
||||
bool sch_pdu::write_packet(uint8_t* ptr)
|
||||
{
|
||||
// Add single or two-byte padding if required
|
||||
if (rem_len == 1 || rem_len == 2) {
|
||||
sch_subh padding;
|
||||
padding.set_padding();
|
||||
for (int i=0;i<rem_len;i++) {
|
||||
padding.write_subheader(&ptr, false);
|
||||
}
|
||||
rem_len = 0;
|
||||
}
|
||||
// Find last SDU or CE
|
||||
int last_sdu = nof_subheaders-1;
|
||||
while(!subheaders[last_sdu].is_sdu() && last_sdu >= 0) {
|
||||
last_sdu--;
|
||||
}
|
||||
int last_ce = nof_subheaders-1;
|
||||
while(subheaders[last_ce].is_sdu() && last_ce >= 0) {
|
||||
last_ce--;
|
||||
}
|
||||
int last_sh = subheaders[last_sdu].is_sdu()?last_sdu:last_ce;
|
||||
// Write subheaders for MAC CE first
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
if (!subheaders[i].is_sdu()) {
|
||||
subheaders[i].write_subheader(&ptr, i==last_sh);
|
||||
}
|
||||
}
|
||||
// Then for SDUs
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
if (subheaders[i].is_sdu()) {
|
||||
subheaders[i].write_subheader(&ptr, i==last_sh);
|
||||
}
|
||||
}
|
||||
// Write payloads in the same order
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
if (!subheaders[i].is_sdu()) {
|
||||
subheaders[i].write_payload(&ptr);
|
||||
}
|
||||
}
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
if (subheaders[i].is_sdu()) {
|
||||
subheaders[i].write_payload(&ptr);
|
||||
}
|
||||
}
|
||||
// Set paddint to zeros (if any)
|
||||
bzero(ptr, rem_len*sizeof(uint8_t)*8);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
uint32_t sch_pdu::size_plus_header_pdu(uint32_t nbytes)
|
||||
{
|
||||
if (nbytes < 128) {
|
||||
return nbytes + 2;
|
||||
} else {
|
||||
return nbytes + 3;
|
||||
}
|
||||
}
|
||||
bool sch_pdu::has_space_ce(uint32_t nbytes)
|
||||
{
|
||||
if (rem_len >= nbytes + 1) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
bool sch_pdu::has_space_sdu(uint32_t nbytes)
|
||||
{
|
||||
if (rem_len >= size_plus_header_pdu(nbytes)) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
bool sch_pdu::update_space_ce(uint32_t nbytes)
|
||||
{
|
||||
if (has_space_ce(nbytes)) {
|
||||
rem_len -= nbytes + 1;
|
||||
}
|
||||
}
|
||||
bool sch_pdu::update_space_sdu(uint32_t nbytes)
|
||||
{
|
||||
if (has_space_sdu(nbytes)) {
|
||||
rem_len -= size_plus_header_pdu(nbytes);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void sch_subh::init()
|
||||
{
|
||||
lcid = 0;
|
||||
nof_bytes = 0;
|
||||
sdu_payload_ptr = NULL;
|
||||
bzero(ce_payload, sizeof(uint8_t) * MAX_CE_PAYLOAD_LEN);
|
||||
}
|
||||
|
||||
sch_subh::cetype sch_subh::ce_type()
|
||||
{
|
||||
if (lcid >= PHD_REPORT) {
|
||||
return (cetype) lcid;
|
||||
} else {
|
||||
return SDU;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t sch_subh::sizeof_ce(uint32_t lcid, bool is_ul)
|
||||
{
|
||||
if (is_ul) {
|
||||
switch(lcid) {
|
||||
case PHD_REPORT:
|
||||
return 1;
|
||||
case C_RNTI:
|
||||
return 2;
|
||||
case TRUNC_BSR:
|
||||
return 1;
|
||||
case SHORT_BSR:
|
||||
return 1;
|
||||
case LONG_BSR:
|
||||
return 3;
|
||||
case PADDING:
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
switch(lcid) {
|
||||
case CON_RES_ID:
|
||||
return 6;
|
||||
case TA_CMD:
|
||||
return 1;
|
||||
case DRX_CMD:
|
||||
return 0;
|
||||
case PADDING:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
bool sch_subh::is_sdu()
|
||||
{
|
||||
return ce_type() == SDU;
|
||||
}
|
||||
uint16_t sch_subh::get_c_rnti()
|
||||
{
|
||||
return *((uint16_t*) ce_payload);
|
||||
}
|
||||
uint64_t sch_subh::get_con_res_id()
|
||||
{
|
||||
return *((uint64_t*) ce_payload);
|
||||
}
|
||||
uint8_t sch_subh::get_phd()
|
||||
{
|
||||
return *((uint8_t*) ce_payload);
|
||||
}
|
||||
uint32_t sch_subh::get_sdu_lcid()
|
||||
{
|
||||
return *((uint32_t*) ce_payload);
|
||||
}
|
||||
uint32_t sch_subh::get_sdu_nbytes()
|
||||
{
|
||||
return *((uint32_t*) ce_payload);
|
||||
}
|
||||
uint8_t* sch_subh::get_sdu_ptr()
|
||||
{
|
||||
return sdu_payload_ptr;
|
||||
}
|
||||
uint8_t sch_subh::get_ta_cmd()
|
||||
{
|
||||
return *((uint8_t*) ce_payload);
|
||||
}
|
||||
void sch_subh::set_padding()
|
||||
{
|
||||
lcid = PADDING;
|
||||
}
|
||||
bool sch_subh::set_c_rnti(uint16_t crnti)
|
||||
{
|
||||
if (((sch_pdu*)parent)->has_space_ce(2)) {
|
||||
*((uint16_t*) ce_payload) = crnti;
|
||||
lcid = C_RNTI;
|
||||
((sch_pdu*)parent)->update_space_ce(2);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
bool sch_subh::set_con_res_id(uint64_t con_res_id)
|
||||
{
|
||||
if (((sch_pdu*)parent)->has_space_ce(6)) {
|
||||
*((uint64_t*) ce_payload) = con_res_id;
|
||||
lcid = CON_RES_ID;
|
||||
((sch_pdu*)parent)->update_space_ce(6);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
bool sch_subh::set_phd(uint8_t phd)
|
||||
{
|
||||
if (((sch_pdu*)parent)->has_space_ce(1)) {
|
||||
*((uint8_t*) ce_payload) = phd;
|
||||
lcid = PHD_REPORT;
|
||||
((sch_pdu*)parent)->update_space_ce(1);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
bool sch_subh::set_sdu(uint32_t lcid_, uint8_t* ptr, uint32_t nof_bytes_)
|
||||
{
|
||||
if (((sch_pdu*)parent)->has_space_sdu(nof_bytes_)) {
|
||||
sdu_payload_ptr = ptr;
|
||||
nof_bytes = nof_bytes_;
|
||||
lcid = lcid_;
|
||||
((sch_pdu*)parent)->update_space_sdu(nof_bytes_);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
bool sch_subh::set_ta_cmd(uint8_t ta_cmd)
|
||||
{
|
||||
if (((sch_pdu*)parent)->has_space_ce(1)) {
|
||||
*((uint8_t*) ce_payload) = ta_cmd;
|
||||
lcid = TA_CMD;
|
||||
((sch_pdu*)parent)->update_space_ce(1);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// Section 6.2.1
|
||||
void sch_subh::write_subheader(uint8_t** ptr, bool is_last)
|
||||
{
|
||||
if (is_sdu()) {
|
||||
// MAC SDU: R/R/E/LCID/F/L subheader
|
||||
srslte_bit_pack(0, ptr, 2); // R, R
|
||||
srslte_bit_pack(is_last?1:0, ptr, 1); // E
|
||||
srslte_bit_pack(lcid, ptr, 5); // LCID
|
||||
|
||||
// 2nd and 3rd octet
|
||||
srslte_bit_pack(F_bit?1:0, ptr, 1); // F
|
||||
srslte_bit_pack(nof_bytes, ptr, nof_bytes<128?7:15); // L
|
||||
} else {
|
||||
// MAC CE: R/R/E/LCID MAC Subheader
|
||||
srslte_bit_pack(0, ptr, 2); // R, R
|
||||
srslte_bit_pack(is_last?1:0, ptr, 1); // E
|
||||
srslte_bit_pack(lcid, ptr, 5); // LCID
|
||||
}
|
||||
}
|
||||
void sch_subh::write_payload(uint8_t** ptr)
|
||||
{
|
||||
if (is_sdu()) {
|
||||
memcpy(*ptr, sdu_payload_ptr, nof_bytes*8*sizeof(uint8_t));
|
||||
} else {
|
||||
srslte_bit_pack_vector(ce_payload, *ptr, nof_bytes*8);
|
||||
}
|
||||
*ptr += nof_bytes*8;
|
||||
}
|
||||
bool sch_subh::read_subheader(uint8_t** ptr)
|
||||
{
|
||||
// Skip R
|
||||
*ptr += 2;
|
||||
bool e_bit = srslte_bit_unpack(ptr, 1)?true:false;
|
||||
lcid = srslte_bit_unpack(ptr, 5);
|
||||
if (is_sdu()) {
|
||||
F_bit = srslte_bit_unpack(ptr, 1)?true:false;
|
||||
nof_bytes = srslte_bit_unpack(ptr, F_bit?7:15);
|
||||
} else {
|
||||
nof_bytes = sizeof_ce(lcid, parent->is_ul());
|
||||
}
|
||||
return e_bit;
|
||||
}
|
||||
void sch_subh::read_payload(uint8_t** ptr)
|
||||
{
|
||||
if (is_sdu()) {
|
||||
sdu_payload_ptr = *ptr;
|
||||
} else {
|
||||
srslte_bit_unpack_vector(ce_payload, *ptr, nof_bytes*8);
|
||||
}
|
||||
*ptr += nof_bytes*8;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void rar_pdu::fprint(FILE* stream)
|
||||
{
|
||||
fprintf(stream, "MAC PDU for RAR. ");
|
||||
if (has_backoff_indicator) {
|
||||
fprintf(stream, "Backoff Indicator %d. ", backoff_indicator);
|
||||
}
|
||||
pdu::fprint(stream);
|
||||
}
|
||||
|
||||
void rar_subh::fprint(FILE* stream)
|
||||
{
|
||||
fprintf(stream, "RAPID: %d, Temp C-RNTI: %d, TA: %d, UL Grant: ", preamble, temp_rnti, ta);
|
||||
srslte_vec_fprint_hex(stream, grant, 20);
|
||||
}
|
||||
|
||||
rar_pdu::rar_pdu(uint32_t max_rars_) : pdu(max_rars_)
|
||||
{
|
||||
backoff_indicator = 0;
|
||||
has_backoff_indicator = false;
|
||||
}
|
||||
uint8_t rar_pdu::get_backoff()
|
||||
{
|
||||
return backoff_indicator;
|
||||
}
|
||||
bool rar_pdu::has_backoff()
|
||||
{
|
||||
return has_backoff_indicator;
|
||||
}
|
||||
void rar_pdu::set_backoff(uint8_t bi)
|
||||
{
|
||||
has_backoff_indicator = true;
|
||||
backoff_indicator = bi;
|
||||
}
|
||||
|
||||
// Section 6.1.5
|
||||
bool rar_pdu::write_packet(uint8_t* ptr)
|
||||
{
|
||||
// Write Backoff Indicator, if any
|
||||
if (has_backoff_indicator) {
|
||||
if (nof_subheaders > 0) {
|
||||
srslte_bit_pack(1, &ptr, 1); // E
|
||||
srslte_bit_pack(0, &ptr, 1); // T
|
||||
srslte_bit_pack(0, &ptr, 2); // R, R
|
||||
srslte_bit_pack(backoff_indicator, &ptr, 4);
|
||||
}
|
||||
}
|
||||
// Write RAR subheaders
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
subheaders[i].write_subheader(&ptr, i==nof_subheaders-1);
|
||||
}
|
||||
// Write payload
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
subheaders[i].write_payload(&ptr);
|
||||
}
|
||||
// Set paddint to zeros (if any)
|
||||
bzero(ptr, rem_len*sizeof(uint8_t)*8);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void rar_subh::init()
|
||||
{
|
||||
bzero(grant, sizeof(uint8_t) * RAR_GRANT_LEN);
|
||||
ta = 0;
|
||||
temp_rnti = 0;
|
||||
}
|
||||
uint32_t rar_subh::get_rapid()
|
||||
{
|
||||
return preamble;
|
||||
}
|
||||
void rar_subh::get_sched_grant(uint8_t grant_[RAR_GRANT_LEN])
|
||||
{
|
||||
memcpy(grant_, &grant, sizeof(uint8_t)*RAR_GRANT_LEN);
|
||||
}
|
||||
uint32_t rar_subh::get_ta_cmd()
|
||||
{
|
||||
return ta;
|
||||
}
|
||||
uint16_t rar_subh::get_temp_crnti()
|
||||
{
|
||||
return temp_rnti;
|
||||
}
|
||||
void rar_subh::set_rapid(uint32_t rapid)
|
||||
{
|
||||
preamble = rapid;
|
||||
}
|
||||
void rar_subh::set_sched_grant(uint8_t grant_[RAR_GRANT_LEN])
|
||||
{
|
||||
memcpy(&grant, grant_, sizeof(uint8_t)*RAR_GRANT_LEN);
|
||||
}
|
||||
void rar_subh::set_ta_cmd(uint32_t ta_)
|
||||
{
|
||||
ta = ta_;
|
||||
}
|
||||
void rar_subh::set_temp_crnti(uint16_t temp_rnti_)
|
||||
{
|
||||
temp_rnti = temp_rnti_;
|
||||
}
|
||||
// Section 6.2.2
|
||||
void rar_subh::write_subheader(uint8_t** ptr, bool is_last)
|
||||
{
|
||||
srslte_bit_pack(is_last?1:0, ptr, 1); // E
|
||||
srslte_bit_pack(1, ptr, 1); // T
|
||||
srslte_bit_pack(preamble, ptr, 6); // RAPID
|
||||
}
|
||||
// Section 6.2.3
|
||||
void rar_subh::write_payload(uint8_t** ptr)
|
||||
{
|
||||
srslte_bit_pack(0, ptr, 1); // R
|
||||
srslte_bit_pack(ta, ptr, 11); // Timing Adv Cmd
|
||||
memcpy(*ptr, grant, 20*sizeof(uint8_t)); // UL grant
|
||||
*ptr += 20;
|
||||
srslte_bit_pack(temp_rnti, ptr, 16); // Temp C-RNTI
|
||||
}
|
||||
void rar_subh::read_payload(uint8_t** ptr)
|
||||
{
|
||||
*ptr += 1; // R
|
||||
ta = srslte_bit_unpack(ptr, 11); // Timing Adv Cmd
|
||||
memcpy(grant, *ptr, 20*sizeof(uint8_t)); // UL Grant
|
||||
*ptr += 20;
|
||||
temp_rnti = srslte_bit_unpack(ptr, 16); // Temp C-RNTI
|
||||
}
|
||||
bool rar_subh::read_subheader(uint8_t** ptr)
|
||||
{
|
||||
bool e_bit = srslte_bit_unpack(ptr, 1); // E
|
||||
bool type = srslte_bit_unpack(ptr, 1); // T
|
||||
if (type) {
|
||||
preamble = srslte_bit_unpack(ptr, 6); // RAPID
|
||||
} else {
|
||||
// Read Backoff
|
||||
*ptr += 2; // R, R
|
||||
((rar_pdu*)parent)->set_backoff((uint8_t) srslte_bit_unpack(ptr, 4));
|
||||
}
|
||||
return e_bit;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
@ -1,629 +0,0 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 The srsLTE Developers. See the
|
||||
* COPYRIGHT file at the top-level directory of this distribution.
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsLTE library.
|
||||
*
|
||||
* srsLTE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsLTE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include <unistd.h>
|
||||
#include <math.h>
|
||||
#include <sys/time.h>
|
||||
#include <unistd.h>
|
||||
#include <assert.h>
|
||||
#include <signal.h>
|
||||
#include <pthread.h>
|
||||
#include <semaphore.h>
|
||||
|
||||
#include "srslte/srslte.h"
|
||||
|
||||
|
||||
#ifndef DISABLE_UHD
|
||||
#include "srslte/cuhd/cuhd.h"
|
||||
#include "cuhd_utils.h"
|
||||
|
||||
cell_search_cfg_t cell_detect_config = {
|
||||
5000,
|
||||
100, // nof_frames_total
|
||||
10.0 // threshold
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
//#define STDOUT_COMPACT
|
||||
|
||||
#ifndef DISABLE_GRAPHICS
|
||||
#include "srsgui/srsgui.h"
|
||||
void init_plots();
|
||||
pthread_t plot_thread;
|
||||
sem_t plot_sem;
|
||||
uint32_t plot_sf_idx=0;
|
||||
#endif
|
||||
|
||||
|
||||
#define B210_DEFAULT_GAIN 40.0
|
||||
#define B210_DEFAULT_GAIN_CORREC 110.0 // Gain of the Rx chain when the gain is set to 40
|
||||
|
||||
float gain_offset = B210_DEFAULT_GAIN_CORREC;
|
||||
|
||||
|
||||
/**********************************************************************
|
||||
* Program arguments processing
|
||||
***********************************************************************/
|
||||
typedef struct {
|
||||
int nof_subframes;
|
||||
bool disable_plots;
|
||||
int force_N_id_2;
|
||||
bool enable_cfo;
|
||||
int time_offset;
|
||||
uint16_t rnti;
|
||||
char *input_file_name;
|
||||
uint32_t file_nof_prb;
|
||||
char *uhd_args;
|
||||
float uhd_freq;
|
||||
float uhd_freq_offset;
|
||||
float uhd_gain;
|
||||
int net_port;
|
||||
char *net_address;
|
||||
int net_port_signal;
|
||||
char *net_address_signal;
|
||||
}prog_args_t;
|
||||
|
||||
void args_default(prog_args_t *args) {
|
||||
args->nof_subframes = -1;
|
||||
args->rnti = SRSLTE_SIRNTI;
|
||||
args->force_N_id_2 = -1; // Pick the best
|
||||
args->input_file_name = NULL;
|
||||
args->enable_cfo = true;
|
||||
args->time_offset = 0;
|
||||
args->file_nof_prb = 6;
|
||||
args->uhd_args = "";
|
||||
args->uhd_freq = -1.0;
|
||||
args->uhd_freq = 8000000.0;
|
||||
args->uhd_gain = 60.0;
|
||||
args->net_port = -1;
|
||||
args->net_address = "127.0.0.1";
|
||||
args->net_port_signal = -1;
|
||||
args->net_address_signal = "127.0.0.1";
|
||||
}
|
||||
|
||||
void usage(prog_args_t *args, char *prog) {
|
||||
printf("Usage: %s [agilcdnruv] -f rx_frequency (in Hz) | -i input_file\n", prog);
|
||||
#ifndef DISABLE_UHD
|
||||
printf("\t-a UHD args [Default %s]\n", args->uhd_args);
|
||||
printf("\t-g UHD RX gain [Default %.2f dB]\n", args->uhd_gain);
|
||||
printf("\t-o UHD RX freq offset [Default %.1f MHz]\n", args->uhd_freq_offset/1000000);
|
||||
#else
|
||||
printf("\t UHD is disabled. CUHD library not available\n");
|
||||
#endif
|
||||
printf("\t-i input_file [Default USRP]\n");
|
||||
printf("\t-p nof_prb for input file [Default %d]\n", args->file_nof_prb);
|
||||
printf("\t-r RNTI [Default 0x%x]\n",args->rnti);
|
||||
printf("\t-l Force N_id_2 [Default best]\n");
|
||||
printf("\t-c Disable CFO correction [Default %s]\n", args->enable_cfo?"Enabled":"Disabled");
|
||||
printf("\t-t Add time offset [Default %d]\n", args->time_offset);
|
||||
#ifndef DISABLE_GRAPHICS
|
||||
printf("\t-d disable plots [Default enabled]\n");
|
||||
#else
|
||||
printf("\t plots are disabled. Graphics library not available\n");
|
||||
#endif
|
||||
printf("\t-n nof_subframes [Default %d]\n", args->nof_subframes);
|
||||
printf("\t-s remote UDP port to send input signal (-1 does nothing with it) [Default %d]\n", args->net_port_signal);
|
||||
printf("\t-S remote UDP address to send input signal [Default %s]\n", args->net_address_signal);
|
||||
printf("\t-u remote TCP port to send data (-1 does nothing with it) [Default %d]\n", args->net_port);
|
||||
printf("\t-U remote TCP address to send data [Default %s]\n", args->net_address);
|
||||
printf("\t-v [set srslte_verbose to debug, default none]\n");
|
||||
}
|
||||
|
||||
void parse_args(prog_args_t *args, int argc, char **argv) {
|
||||
int opt;
|
||||
args_default(args);
|
||||
while ((opt = getopt(argc, argv, "aoglipdnvrfctuUsS")) != -1) {
|
||||
switch (opt) {
|
||||
case 'i':
|
||||
args->input_file_name = argv[optind];
|
||||
break;
|
||||
case 'p':
|
||||
args->file_nof_prb = atoi(argv[optind]);
|
||||
break;
|
||||
case 'a':
|
||||
args->uhd_args = argv[optind];
|
||||
break;
|
||||
case 'g':
|
||||
args->uhd_gain = atof(argv[optind]);
|
||||
break;
|
||||
case 'o':
|
||||
args->uhd_freq_offset = atof(argv[optind]);
|
||||
break;
|
||||
case 'f':
|
||||
args->uhd_freq = atof(argv[optind]);
|
||||
break;
|
||||
case 'n':
|
||||
args->nof_subframes = atoi(argv[optind]);
|
||||
break;
|
||||
case 'c':
|
||||
args->enable_cfo = false;
|
||||
break;
|
||||
case 't':
|
||||
args->time_offset = atoi(argv[optind]);
|
||||
break;
|
||||
case 'r':
|
||||
args->rnti = atoi(argv[optind]);
|
||||
break;
|
||||
case 'l':
|
||||
args->force_N_id_2 = atoi(argv[optind]);
|
||||
break;
|
||||
case 'u':
|
||||
args->net_port = atoi(argv[optind]);
|
||||
break;
|
||||
case 'U':
|
||||
args->net_address = argv[optind];
|
||||
break;
|
||||
case 's':
|
||||
args->net_port_signal = atoi(argv[optind]);
|
||||
break;
|
||||
case 'S':
|
||||
args->net_address_signal = argv[optind];
|
||||
break;
|
||||
case 'd':
|
||||
args->disable_plots = true;
|
||||
break;
|
||||
case 'v':
|
||||
srslte_verbose++;
|
||||
break;
|
||||
default:
|
||||
usage(args, argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
if (args->uhd_freq < 0 && args->input_file_name == NULL) {
|
||||
usage(args, argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
/**********************************************************************/
|
||||
|
||||
/* TODO: Do something with the output data */
|
||||
uint8_t data[20000], data_packed[20000];
|
||||
|
||||
bool go_exit = false;
|
||||
|
||||
void sig_int_handler(int signo)
|
||||
{
|
||||
if (signo == SIGINT) {
|
||||
go_exit = true;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef DISABLE_UHD
|
||||
int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples, srslte_timestamp_t *t) {
|
||||
DEBUG(" ---- Receive %d samples ---- \n", nsamples);
|
||||
return cuhd_recv(h, data, nsamples, 1);
|
||||
}
|
||||
#endif
|
||||
|
||||
extern float mean_exec_time;
|
||||
|
||||
enum receiver_state { DECODE_MIB, DECODE_PDSCH} state;
|
||||
|
||||
srslte_ue_dl_t ue_dl;
|
||||
srslte_ue_sync_t ue_sync;
|
||||
prog_args_t prog_args;
|
||||
|
||||
uint32_t sfn = 0; // system frame number
|
||||
cf_t *sf_buffer = NULL;
|
||||
srslte_netsink_t net_sink, net_sink_signal;
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int ret;
|
||||
srslte_cell_t cell;
|
||||
int64_t sf_cnt;
|
||||
srslte_ue_mib_t ue_mib;
|
||||
#ifndef DISABLE_UHD
|
||||
void *uhd;
|
||||
#endif
|
||||
uint32_t nof_trials = 0;
|
||||
int n;
|
||||
uint8_t bch_payload[SRSLTE_BCH_PAYLOAD_LEN];
|
||||
uint32_t sfn_offset;
|
||||
|
||||
parse_args(&prog_args, argc, argv);
|
||||
|
||||
if (prog_args.net_port > 0) {
|
||||
if (srslte_netsink_init(&net_sink, prog_args.net_address, prog_args.net_port, SRSLTE_NETSINK_TCP)) {
|
||||
fprintf(stderr, "Error initiating UDP socket to %s:%d\n", prog_args.net_address, prog_args.net_port);
|
||||
exit(-1);
|
||||
}
|
||||
srslte_netsink_set_nonblocking(&net_sink);
|
||||
}
|
||||
if (prog_args.net_port_signal > 0) {
|
||||
if (srslte_netsink_init(&net_sink_signal, prog_args.net_address_signal, prog_args.net_port_signal, SRSLTE_NETSINK_UDP)) {
|
||||
fprintf(stderr, "Error initiating UDP socket to %s:%d\n", prog_args.net_address_signal, prog_args.net_port_signal);
|
||||
exit(-1);
|
||||
}
|
||||
srslte_netsink_set_nonblocking(&net_sink_signal);
|
||||
}
|
||||
|
||||
#ifndef DISABLE_UHD
|
||||
if (!prog_args.input_file_name) {
|
||||
printf("Opening UHD device...\n");
|
||||
if (cuhd_open(prog_args.uhd_args, &uhd)) {
|
||||
fprintf(stderr, "Error opening uhd\n");
|
||||
exit(-1);
|
||||
}
|
||||
/* Set receiver gain */
|
||||
cuhd_set_rx_gain(uhd, prog_args.uhd_gain);
|
||||
|
||||
/* set receiver frequency */
|
||||
cuhd_set_rx_freq_offset(uhd, (double) prog_args.uhd_freq, prog_args.uhd_freq_offset);
|
||||
cuhd_rx_wait_lo_locked(uhd);
|
||||
printf("Tunning receiver to %.3f MHz\n", (double ) prog_args.uhd_freq/1000000);
|
||||
|
||||
ret = cuhd_search_and_decode_mib(uhd, &cell_detect_config, prog_args.force_N_id_2, &cell);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Error searching for cell\n");
|
||||
exit(-1);
|
||||
} else if (ret == 0) {
|
||||
printf("Cell not found\n");
|
||||
exit(0);
|
||||
}
|
||||
|
||||
/* set sampling frequency */
|
||||
int srate = srslte_sampling_freq_hz(cell.nof_prb);
|
||||
if (srate != -1) {
|
||||
cuhd_set_rx_srate(uhd, (double) srate);
|
||||
} else {
|
||||
fprintf(stderr, "Invalid number of PRB %d\n", cell.nof_prb);
|
||||
return SRSLTE_ERROR;
|
||||
}
|
||||
|
||||
INFO("Stopping UHD and flushing buffer...\r",0);
|
||||
cuhd_stop_rx_stream(uhd);
|
||||
cuhd_flush_buffer(uhd);
|
||||
|
||||
if (srslte_ue_mib_init(&ue_mib, cell)) {
|
||||
fprintf(stderr, "Error initaiting UE MIB decoder\n");
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* If reading from file, go straight to PDSCH decoding. Otherwise, decode MIB first */
|
||||
if (prog_args.input_file_name) {
|
||||
state = DECODE_PDSCH;
|
||||
/* preset cell configuration */
|
||||
cell.id = 1;
|
||||
cell.cp = SRSLTE_CP_NORM;
|
||||
cell.phich_length = SRSLTE_PHICH_NORM;
|
||||
cell.phich_resources = SRSLTE_PHICH_R_1;
|
||||
cell.nof_ports = 1;
|
||||
cell.nof_prb = prog_args.file_nof_prb;
|
||||
|
||||
if (srslte_ue_sync_init_file(&ue_sync, prog_args.file_nof_prb, prog_args.input_file_name)) {
|
||||
fprintf(stderr, "Error initiating ue_sync\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
} else {
|
||||
#ifndef DISABLE_UHD
|
||||
state = DECODE_MIB;
|
||||
if (srslte_ue_sync_init(&ue_sync, cell, cuhd_recv_wrapper, uhd)) {
|
||||
fprintf(stderr, "Error initiating ue_sync\n");
|
||||
exit(-1);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
if (srslte_ue_dl_init(&ue_dl, cell)) { // This is the User RNTI
|
||||
fprintf(stderr, "Error initiating UE downlink processing module\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
/* Configure downlink receiver for the SI-RNTI since will be the only one we'll use */
|
||||
srslte_ue_dl_set_rnti(&ue_dl, prog_args.rnti);
|
||||
|
||||
/* Initialize subframe counter */
|
||||
sf_cnt = 0;
|
||||
|
||||
// Register Ctrl+C handler
|
||||
signal(SIGINT, sig_int_handler);
|
||||
|
||||
#ifndef DISABLE_GRAPHICS
|
||||
if (!prog_args.disable_plots) {
|
||||
init_plots(cell);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef DISABLE_UHD
|
||||
if (!prog_args.input_file_name) {
|
||||
cuhd_start_rx_stream(uhd);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Variables for measurements
|
||||
uint32_t nframes=0;
|
||||
float rsrp=0.0, rsrq=0.0, snr=0.0;
|
||||
bool decode_pdsch;
|
||||
int pdcch_tx=0;
|
||||
srslte_ra_dl_dci_t old_ra_dl;
|
||||
bzero(&old_ra_dl, sizeof(srslte_ra_dl_dci_t));
|
||||
|
||||
ue_sync.correct_cfo = prog_args.enable_cfo;
|
||||
|
||||
/* Main loop */
|
||||
while (!go_exit && (sf_cnt < prog_args.nof_subframes || prog_args.nof_subframes == -1)) {
|
||||
|
||||
ret = srslte_ue_sync_get_buffer(&ue_sync, &sf_buffer);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Error calling srslte_ue_sync_work()\n");
|
||||
}
|
||||
|
||||
/* srslte_ue_sync_get_buffer returns 1 if successfully read 1 aligned subframe */
|
||||
if (ret == 1) {
|
||||
switch (state) {
|
||||
case DECODE_MIB:
|
||||
if (srslte_ue_sync_get_sfidx(&ue_sync) == 0) {
|
||||
srslte_pbch_decode_reset(&ue_mib.pbch);
|
||||
n = srslte_ue_mib_decode(&ue_mib, sf_buffer, bch_payload, NULL, &sfn_offset);
|
||||
if (n < 0) {
|
||||
fprintf(stderr, "Error decoding UE MIB\n");
|
||||
exit(-1);
|
||||
} else if (n == SRSLTE_UE_MIB_FOUND) {
|
||||
srslte_pbch_mib_unpack(bch_payload, &cell, &sfn);
|
||||
srslte_cell_fprint(stdout, &cell, sfn);
|
||||
printf("Decoded MIB. SFN: %d, offset: %d\n", sfn, sfn_offset);
|
||||
sfn = (sfn + sfn_offset)%1024;
|
||||
state = DECODE_PDSCH;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case DECODE_PDSCH:
|
||||
if (prog_args.rnti != SRSLTE_SIRNTI) {
|
||||
decode_pdsch = true;
|
||||
} else {
|
||||
/* We are looking for SIB1 Blocks, search only in appropiate places */
|
||||
if ((srslte_ue_sync_get_sfidx(&ue_sync) == 5 && (sfn%2)==0)) {
|
||||
decode_pdsch = true;
|
||||
} else {
|
||||
decode_pdsch = false;
|
||||
}
|
||||
}
|
||||
if (decode_pdsch) {
|
||||
if (prog_args.rnti != SRSLTE_SIRNTI) {
|
||||
n = srslte_ue_dl_decode(&ue_dl, &sf_buffer[prog_args.time_offset], data_packed, srslte_ue_sync_get_sfidx(&ue_sync));
|
||||
} else {
|
||||
n = srslte_ue_dl_decode_rnti_rv(&ue_dl, &sf_buffer[prog_args.time_offset], data_packed, srslte_ue_sync_get_sfidx(&ue_sync), SRSLTE_SIRNTI,
|
||||
((int) ceilf((float)3*(((sfn)/2)%4)/2))%4);
|
||||
}
|
||||
if (memcmp(&ue_dl.ra_dl, &old_ra_dl, sizeof(srslte_ra_dl_dci_t))) {
|
||||
memcpy(&old_ra_dl, &ue_dl.ra_dl, sizeof(srslte_ra_dl_dci_t));
|
||||
fflush(stdout);printf("\nCFI:\t%d\n", ue_dl.cfi);
|
||||
printf("Format: %s\n", srslte_dci_format_string(ue_dl.dci_format));
|
||||
srslte_ra_pdsch_fprint(stdout, &old_ra_dl, cell.nof_prb);
|
||||
}
|
||||
if (n < 0) {
|
||||
// fprintf(stderr, "Error decoding UE DL\n");fflush(stdout);
|
||||
} else if (n > 0) {
|
||||
/* Send data if socket active */
|
||||
if (prog_args.net_port > 0) {
|
||||
srslte_bit_unpack_vector(data_packed, data, n);
|
||||
srslte_netsink_write(&net_sink, data, 1+(n-1)/8);
|
||||
}
|
||||
}
|
||||
nof_trials++;
|
||||
|
||||
rsrq = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrq(&ue_dl.chest), rsrq, 0.05);
|
||||
rsrp = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrp(&ue_dl.chest), rsrp, 0.05);
|
||||
snr = SRSLTE_VEC_EMA(srslte_chest_dl_get_snr(&ue_dl.chest), snr, 0.01);
|
||||
nframes++;
|
||||
if (isnan(rsrq)) {
|
||||
rsrq = 0;
|
||||
}
|
||||
if (isnan(snr)) {
|
||||
snr = 0;
|
||||
}
|
||||
if (isnan(rsrp)) {
|
||||
rsrp = 0;
|
||||
}
|
||||
|
||||
#ifdef adjust_estimator
|
||||
/* Adjust channel estimator based on SNR */
|
||||
if (10*log10(snr) < 5.0) {
|
||||
float f_low_snr[5]={0.05, 0.15, 0.6, 0.15, 0.05};
|
||||
srslte_chest_dl_set_filter_freq(&ue_dl.chest, f_low_snr, 5);
|
||||
} else if (10*log10(snr) < 10.0) {
|
||||
float f_mid_snr[3]={0.1, 0.8, 0.1};
|
||||
srslte_chest_dl_set_filter_freq(&ue_dl.chest, f_mid_snr, 3);
|
||||
} else {
|
||||
float f_high_snr[3]={0.05, 0.9, 0.05};
|
||||
srslte_chest_dl_set_filter_freq(&ue_dl.chest, f_high_snr, 3);
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
if (srslte_ue_sync_get_sfidx(&ue_sync) != 5 && srslte_ue_sync_get_sfidx(&ue_sync) != 0) {
|
||||
pdcch_tx++;
|
||||
}
|
||||
|
||||
|
||||
// Plot and Printf
|
||||
if (srslte_ue_sync_get_sfidx(&ue_sync) == 5) {
|
||||
#ifdef STDOUT_COMPACT
|
||||
printf("SFN: %4d, PDCCH-Miss: %5.2f%% (%d missed), PDSCH-BLER: %5.2f%% (%d errors)\r",
|
||||
sfn, 100*(1-(float) ue_dl.nof_detected/nof_trials),pdcch_tx-ue_dl.nof_detected,
|
||||
(float) 100*ue_dl.pkt_errors/ue_dl.pkts_total,ue_dl.pkt_errors);
|
||||
#else
|
||||
printf("CFO: %+6.2f KHz, SFO: %+6.2f Khz, "
|
||||
"RSRP: %+5.1f dBm, RSRQ: %5.1f dB, SNR: %4.1f dB, "
|
||||
"PDCCH-Miss: %5.2f%% (%d), PDSCH-BLER: %5.2f%% (%d)\r",
|
||||
srslte_ue_sync_get_cfo(&ue_sync)/1000, srslte_ue_sync_get_sfo(&ue_sync)/1000,
|
||||
10*log10(rsrp*1000)-gain_offset,
|
||||
10*log10(rsrq), 10*log10(snr),
|
||||
100*(1-(float) ue_dl.nof_detected/nof_trials), pdcch_tx-ue_dl.nof_detected,
|
||||
(float) 100*ue_dl.pkt_errors/ue_dl.pkts_total, ue_dl.pkt_errors);
|
||||
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (srslte_ue_sync_get_sfidx(&ue_sync) == 9) {
|
||||
sfn++;
|
||||
if (sfn == 1024) {
|
||||
sfn = 0;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef DISABLE_GRAPHICS
|
||||
if (!prog_args.disable_plots) {
|
||||
plot_sf_idx = srslte_ue_sync_get_sfidx(&ue_sync);
|
||||
sem_post(&plot_sem);
|
||||
}
|
||||
#endif
|
||||
} else if (ret == 0) {
|
||||
printf("Finding PSS... Peak: %8.1f, FrameCnt: %d, State: %d\r",
|
||||
srslte_sync_get_peak_value(&ue_sync.sfind),
|
||||
ue_sync.frame_total_cnt, ue_sync.state);
|
||||
}
|
||||
|
||||
sf_cnt++;
|
||||
} // Main loop
|
||||
|
||||
srslte_ue_dl_free(&ue_dl);
|
||||
srslte_ue_sync_free(&ue_sync);
|
||||
|
||||
#ifndef DISABLE_UHD
|
||||
if (!prog_args.input_file_name) {
|
||||
srslte_ue_mib_free(&ue_mib);
|
||||
cuhd_close(uhd);
|
||||
}
|
||||
#endif
|
||||
printf("\nBye\n");
|
||||
exit(0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/**********************************************************************
|
||||
* Plotting Functions
|
||||
***********************************************************************/
|
||||
#ifndef DISABLE_GRAPHICS
|
||||
|
||||
|
||||
plot_real_t poutfft;
|
||||
plot_real_t pce_angle, pce;
|
||||
plot_scatter_t pscatequal, pscatequal_pdcch;
|
||||
|
||||
float tmp_plot[SRSLTE_SLOT_LEN_RE(SRSLTE_MAX_PRB, SRSLTE_CP_NORM)];
|
||||
float tmp_plot2[SRSLTE_SLOT_LEN_RE(SRSLTE_MAX_PRB, SRSLTE_CP_NORM)];
|
||||
float tmp_plot3[SRSLTE_SLOT_LEN_RE(SRSLTE_MAX_PRB, SRSLTE_CP_NORM)];
|
||||
|
||||
void *plot_thread_run(void *arg) {
|
||||
int i;
|
||||
uint32_t nof_re = SRSLTE_SF_LEN_RE(ue_dl.cell.nof_prb, ue_dl.cell.cp);
|
||||
|
||||
while(1) {
|
||||
sem_wait(&plot_sem);
|
||||
|
||||
uint32_t nof_symbols = ue_dl.harq_process[0].dl_alloc.re_sf[plot_sf_idx];
|
||||
for (i = 0; i < nof_re; i++) {
|
||||
tmp_plot[i] = 20 * log10f(cabsf(ue_dl.sf_symbols[i]));
|
||||
if (isinf(tmp_plot[i])) {
|
||||
tmp_plot[i] = -80;
|
||||
}
|
||||
}
|
||||
for (i = 0; i < SRSLTE_REFSIGNAL_NUM_SF(ue_dl.cell.nof_prb,0); i++) {
|
||||
tmp_plot2[i] = 20 * log10f(cabsf(ue_dl.chest.pilot_estimates_average[0][i]));
|
||||
if (isinf(tmp_plot2[i])) {
|
||||
tmp_plot2[i] = -80;
|
||||
}
|
||||
}
|
||||
for (i = 0; i < SRSLTE_REFSIGNAL_NUM_SF(ue_dl.cell.nof_prb,0); i++) {
|
||||
tmp_plot3[i] = cargf(ue_dl.chest.pilot_estimates_average[0][i]);
|
||||
}
|
||||
plot_real_setNewData(&poutfft, tmp_plot, nof_re);
|
||||
plot_real_setNewData(&pce, tmp_plot2, SRSLTE_REFSIGNAL_NUM_SF(ue_dl.cell.nof_prb,0));
|
||||
plot_real_setNewData(&pce_angle, tmp_plot3, SRSLTE_REFSIGNAL_NUM_SF(ue_dl.cell.nof_prb,0));
|
||||
|
||||
plot_scatter_setNewData(&pscatequal, ue_dl.pdsch.d, nof_symbols);
|
||||
plot_scatter_setNewData(&pscatequal_pdcch, ue_dl.pdcch.d, 36*ue_dl.pdcch.nof_cce);
|
||||
|
||||
if (plot_sf_idx == 1) {
|
||||
if (prog_args.net_port_signal > 0) {
|
||||
srslte_netsink_write(&net_sink_signal, &sf_buffer[srslte_ue_sync_sf_len(&ue_sync)/7],
|
||||
srslte_ue_sync_sf_len(&ue_sync));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void init_plots() {
|
||||
|
||||
sdrgui_init();
|
||||
|
||||
plot_real_init(&poutfft);
|
||||
plot_real_setTitle(&poutfft, "Output FFT - Magnitude");
|
||||
plot_real_setLabels(&poutfft, "Index", "dB");
|
||||
plot_real_setYAxisScale(&poutfft, -40, 40);
|
||||
|
||||
plot_real_init(&pce);
|
||||
plot_real_setTitle(&pce, "Channel Response - Magnitude");
|
||||
plot_real_setLabels(&pce, "Index", "dB");
|
||||
|
||||
plot_real_init(&pce_angle);
|
||||
plot_real_setTitle(&pce_angle, "Channel Response - Argument");
|
||||
plot_real_setLabels(&pce_angle, "Index", "Radiants");
|
||||
plot_real_setYAxisScale(&pce_angle, -M_PI, M_PI);
|
||||
|
||||
plot_scatter_init(&pscatequal);
|
||||
plot_scatter_setTitle(&pscatequal, "PDSCH - Equalized Symbols");
|
||||
plot_scatter_setXAxisScale(&pscatequal, -2, 2);
|
||||
plot_scatter_setYAxisScale(&pscatequal, -2, 2);
|
||||
|
||||
plot_scatter_init(&pscatequal_pdcch);
|
||||
plot_scatter_setTitle(&pscatequal_pdcch, "PDCCH - Equalized Symbols");
|
||||
plot_scatter_setXAxisScale(&pscatequal_pdcch, -2, 2);
|
||||
plot_scatter_setYAxisScale(&pscatequal_pdcch, -2, 2);
|
||||
|
||||
if (sem_init(&plot_sem, 0, 0)) {
|
||||
perror("sem_init");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
if (pthread_create(&plot_thread, NULL, plot_thread_run, NULL)) {
|
||||
perror("pthread_create");
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue