Open crest4162 opened 4 months ago
hdtuanss
commented
3 months ago Hi, could you share your experiment setup? I have not been successful in using PPS reference signal for synchronizing multiple USRPs. Did you change some code of LTESniffer to make it work? Based on my experiments before, using PPS seems to have bad sync.
crest4162
commented
3 months ago Hi @hdtuanss,
I will happily share my setup.
I have two B205mini USRPs taking a PPS reference from a GPS evaluation kit (just the easiest precision time pulse I have available). I am using UHD 4.6.0 with b2xx_b205mini_fpga_default (from uhd_images_downloader at https://files.ettus.com/binaries/cache/b2xx/uhd-92c09f7/b2xx_b205mini_fpga_default-g92c09f7.zip).
I did make some code changes to LTESniffer:
git diff CMakeLists.txt:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5ec2d0d..6afe713 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -188,6 +188,10 @@ else(SRSRAN_FOUND AND NOT FORCE_SUBPROJECT_SRSRAN)
# let the compiler find included files from subdirectories
include_directories(".")
+ file(COPY "${CMAKE_BINARY_DIR}/srsRAN-src/lib/src/phy/rf/"
+ DESTINATION "${CMAKE_BINARY_DIR}/srsRAN-src/lib/include/srsran/phy/rf"
+ FILES_MATCHING PATTERN "rf_uhd_*.h")
+
# Add srsRAN directly to our build.
add_subdirectory("${CMAKE_BINARY_DIR}/srsRAN-src"
"${CMAKE_BINARY_DIR}/srsRAN-build")git diff src/src/LTESniffer_Core.cc:
diff --git a/src/src/LTESniffer_Core.cc b/src/src/LTESniffer_Core.cc
index 1f68cdb..089cfc9 100644
--- a/src/src/LTESniffer_Core.cc
+++ b/src/src/LTESniffer_Core.cc
@@ -28,6 +28,8 @@
#undef I // Fix complex.h #define I nastiness when using C++
#endif
+#include "srsran/phy/rf/rf_uhd_imp.h"
+
#define ENABLE_AGC_DEFAULT
using namespace std;
@@ -176,8 +178,8 @@ bool LTESniffer_Core::run(){
printf("Opening RF device with %d RX antennas...\n", args.rf_nof_rx_ant);
char rfArgsCStr_a[1024];
char rfArgsCStr_b[1024];
- std::string rf_a_string = "clock=gpsdo,num_recv_frames=512,recv_frame_size=8000,serial=3113D1B";
- std::string rf_b_string = "clock=gpsdo,num_recv_frames=512,recv_frame_size=8000,serial=3125CB5";
+ std::string rf_a_string = "time_source=external,num_recv_frames=512,recv_frame_size=8000,serial=xxxxxxx";
+ std::string rf_b_string = "time_source=external,num_recv_frames=512,recv_frame_size=8000,serial=xxxxxxx";
/*The following strings are for USRP X310 for specific application*/
// std::string rf_a_string = "clock=gpsdo,type=x300,addr=192.168.40.2";
@@ -290,6 +292,16 @@ bool LTESniffer_Core::run(){
}
#endif
+ // usrp time sync via ref
+ printf("Synchronizing RF devices against PPS...\n");
+ void* handler_ptrs[2] = {rf_a.handler, rf_b.handler};
+ ret = rf_uhd_sync_pps_multi(handler_ptrs, 2);
+ if (ret != SRSRAN_SUCCESS) {
+ ERROR("Failed to synchronize RF devices: srsRAN errno %d\n", ret);
+ exit(-1);
+ }
+ printf("Synchronized RF devices.\n");
+
/* If reading from file, go straight to PDSCH decoding. Otherwise, decode MIB first */
if (args.input_file_name != "") {
/* preset cell configuration */I also made additions to your multi-usrp fork of srsRAN:
git diff lib/src/phy/rf/rf_uhd_generic.h:
diff --git a/lib/src/phy/rf/rf_uhd_generic.h b/lib/src/phy/rf/rf_uhd_generic.h
index d8fdf4b..b7bda91 100644
--- a/lib/src/phy/rf/rf_uhd_generic.h
+++ b/lib/src/phy/rf/rf_uhd_generic.h
@@ -289,6 +289,15 @@ public:
Debug("Setting Time at next PPS...");
SRSRAN_UHD_SAFE_C_LOG_ERROR(usrp->set_time_unknown_pps(timespec);)
}
+ uhd_error set_time_next_pps(const uhd::time_spec_t& timespec)
+ {
+ Debug("Setting Time at next PPS...");
+ SRSRAN_UHD_SAFE_C_LOG_ERROR(usrp->set_time_next_pps(timespec);)
+ }
+ uhd_error get_time_last_pps(uhd::time_spec_t& timespec)
+ {
+ SRSRAN_UHD_SAFE_C_LOG_ERROR(timespec = usrp->get_time_last_pps();)
+ }
uhd_error get_time_now(uhd::time_spec_t& timespec) override
{
SRSRAN_UHD_SAFE_C_LOG_ERROR(timespec = usrp->get_time_now();)git diff lib/src/phy/rf/rf_uhd_imp.cc:
diff --git a/lib/src/phy/rf/rf_uhd_imp.cc b/lib/src/phy/rf/rf_uhd_imp.cc
index 1d90e49..676f709 100644
--- a/lib/src/phy/rf/rf_uhd_imp.cc
+++ b/lib/src/phy/rf/rf_uhd_imp.cc
@@ -625,18 +625,15 @@ static int uhd_init(rf_uhd_handler_t* handler, char* args, uint32_t nof_channels
// Initialize handler
handler->uhd_error_handler = nullptr;
- // Check external clock argument
+ // Check external clock and time arguments
std::string clock_src = "internal";
- if (device_addr.has_key("clock")) {
- clock_src = device_addr.pop("clock");
+ if (device_addr.has_key("clock_source")) {
+ clock_src = device_addr.pop("clock_source");
+ }
+ std::string time_src = "internal";
+ if (device_addr.has_key("time_source")) {
+ time_src = device_addr.pop("time_source");
}
-
- // Select same synchronization source only if more than one channel is opened
- std::string sync_src = "internal";
- sync_src = clock_src;
- // if (nof_channels > 1) {
- // sync_src = clock_src;
- // }
// Logging level
#ifdef UHD_LOG_INFO
@@ -812,7 +809,7 @@ static int uhd_init(rf_uhd_handler_t* handler, char* args, uint32_t nof_channels
std::string sensor_name;
// Set sync source
- if (handler->uhd->set_sync_source(sync_src, clock_src) != UHD_ERROR_NONE) {
+ if (handler->uhd->set_sync_source(time_src, clock_src) != UHD_ERROR_NONE) {
return SRSRAN_ERROR;
}
@@ -1545,3 +1542,45 @@ int rf_uhd_send_timed_multi(void* h,
return nsamples;
}
+
+
+static bool wait_for_pps(rf_uhd_handler_t* h) {
+ const auto deadline = std::chrono::steady_clock::now() +
+ std::chrono::seconds(2);
+
+ uhd::time_spec_t t_pps_initial;
+ h->uhd->get_time_last_pps(t_pps_initial);
+ while (std::chrono::steady_clock::now() < deadline) {
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ uhd::time_spec_t t_pps_last;
+ h->uhd->get_time_last_pps(t_pps_last);
+ if (t_pps_last != t_pps_initial) {
+ return true;
+ }
+ }
+
+ return false;
+};
+
+int rf_uhd_sync_pps_multi(void** hs, size_t num_h) {
+ if (num_h == 0) {
+ return SRSRAN_ERROR_INVALID_INPUTS;
+ }
+
+ rf_uhd_handler_t** handlers = (rf_uhd_handler_t**)hs;
+
+ if (!wait_for_pps(handlers[0])) {
+ return SRSRAN_ERROR_TIMEOUT;
+ }
+
+ uhd::time_spec_t zero_time {0.0};
+ for (size_t i = 0; i < num_h; i++) {
+ handlers[i]->uhd->set_time_next_pps(zero_time);
+ }
+
+ if (!wait_for_pps(handlers[0])) {
+ return SRSRAN_ERROR_TIMEOUT;
+ }
+
+ return SRSRAN_SUCCESS;
+}git diff lib/src/phy/rf/rf_uhd_imp.h:
diff --git a/lib/src/phy/rf/rf_uhd_imp.h b/lib/src/phy/rf/rf_uhd_imp.h
index 925a5d7..9cd45da 100644
--- a/lib/src/phy/rf/rf_uhd_imp.h
+++ b/lib/src/phy/rf/rf_uhd_imp.h
@@ -112,6 +112,8 @@ SRSRAN_API int rf_uhd_send_timed_multi(void* h,
bool is_start_of_burst,
bool is_end_of_burst);
+SRSRAN_API int rf_uhd_sync_pps_multi(void** hs, size_t num_h);
+
#ifdef __cplusplus
}
#endifgit diff lib/src/phy/rf/rf_uhd_safe.h:
diff --git a/lib/src/phy/rf/rf_uhd_safe.h b/lib/src/phy/rf/rf_uhd_safe.h
index d09dfc7..bef44cc 100644
--- a/lib/src/phy/rf/rf_uhd_safe.h
+++ b/lib/src/phy/rf/rf_uhd_safe.h
@@ -145,6 +145,8 @@ public:
virtual uhd_error get_sensor(const std::string& sensor_name, bool& sensor_value) = 0;
virtual uhd_error get_rx_sensor(const std::string& sensor_name, bool& sensor_value) = 0;
virtual uhd_error set_time_unknown_pps(const uhd::time_spec_t& timespec) = 0;
+ virtual uhd_error set_time_next_pps(const uhd::time_spec_t& timespec) = 0;
+ virtual uhd_error get_time_last_pps(uhd::time_spec_t& timespec) = 0;
virtual uhd_error get_time_now(uhd::time_spec_t& timespec) = 0;
uhd_error start_rx_stream(double delay)
{My changes to your multi-usrp fork of srsRAN kind of break API boundaries so some other hacks (a copy directive in CMakeLists.txt and an include in LTESniffer_core.cc - seen in LTESniffer diffs 1 and 2 above) are required to compile. For this same reason, I decided not to share these changes to GitHub.
I would be happy to push branches with these code changes if that is desired.
hdtuanss
commented
3 months ago Hi, it seems you are having the same test as me before. I also tried to modify srsRAN code related to USRP to achieve synchronization by PPS. Unfortunately, the synchronization was really bad and that is the reason why you have many failed cases and variance in SNR. I still do not have any idea how to solve this problem. I hope you can solve it and definitely it will be a great contribution
crest4162
commented
3 months ago Hi @hdtuanss thanks for getting back.
Could you please share info about your setup when you attempted PPS synchronization? More specifically, what USRPs did you attempt with? I am curious if you had similar issues with a different model of USRP.
crest4162
commented
3 months ago After thinking about this problem more, I decided it might be useful to provide some additional information.
With the aforementioned PPS-synchronized dual-USRP setup, I have attempted some different eNB/UE combinations. This table shows PUSCH decoding reliability of LTESniffer with each combination of eNB and UE implementation. The sniffer was placed close to the eNB in each case to mitigate propagation delay.
| srsRAN eNB | Commercial eNB | |
|---|---|---|
| srsRAN UE | high success | low success |
| COTS UE | high success | low success |
Many different physical layer configurations were tested for both eNB implementations.
I believe this is a partial validation of the PPS-synchronized setup.
hdtuanss
commented
3 months ago Hi, It is understandable that you got high success in srsRAN and low success in commercial eNB. In the srsRAN, as the sniffer is close to eNB, the downlink-uplink subframes are almost aligned. Also, srsRAN usually uses low modulation and coding schemes, making the decoding process much easier. I'm sorry that right now I dont have any time to develop the synchronization function using PPS. I will notify you as soon as I have any updates regarding this problem. Thanks.
crest4162
commented
3 months ago Hi @hdtuanss thanks for getting back again.
This project is of high importance to me. I am in the position to offer compensation in return for improvements to decoding reliability and 4-port cell support in general. I will send you an email to continue this discussion.
If anyone else reading this is interested in the contract offer, please email me at crest4162@gmail.com.
Hello again! For context, this post serves as a continuation of a previous one where I was attempting uplink decoding using a pair of USRP B205minis w/ a PPS for time alignment. That thread ended with a discussion about the limitation of the underlying srsRAN library to 1 and 2 port cells.
I have recently found a 2-port eNB (10 MHz bandwidth) that my COTS phones will connect to. I placed the sniffer in an area with good signal quality (>20 SNR). With a phone ~1 meter from the USRPs, I switched airplane mode on and off several times. Upon switching airplane mode off, the RACH and RRC Connection Setup can be seen, but no further results are present.
The following text shows 5 instances of switching airplane mode from a run with arguments
... -m 1 -z 3 -d. It was generated by filtering LTESniffer output with the commandgrep -v Paging <sniffer output file> | grep -A 10 PRACH.I expected further messages to be decoded (e.g., Attach Request). I was also surprised to see such variance in SNR for any one RNTI, and this appears to affect decoding reliability.
Thanks in advance!