Tracker works with hackrf now! AGC seems important, and needs to be implemented

sdr-x · sdr-x · commit cac2138eab7a · 2014-04-10T23:47:28.000+08:00
diff --git a/include/LTE-Tracker.h b/include/LTE-Tracker.h
@@ -208,6 +208,17 @@ class global_thread_data_t {
       boost::mutex::scoped_lock lock(opencl_device_mutex);
       opencl_device_private=f;
     }
+
+    inline int dev_use() {
+      boost::mutex::scoped_lock lock(dev_use_mutex);
+      int r=dev_use_private;
+      return r;
+    }
+    inline void dev_use(const int & f) {
+      boost::mutex::scoped_lock lock(dev_use_mutex);
+      dev_use_private=f;
+    }
+
     inline uint16 opencl_platform() {
       boost::mutex::scoped_lock lock(opencl_platform_mutex);
       uint16 r=opencl_platform_private;
@@ -325,6 +336,9 @@ class global_thread_data_t {
     boost::mutex opencl_platform_mutex;
     uint16 opencl_platform_private;
 
+    boost::mutex dev_use_mutex;
+    int dev_use_private;
+
     boost::mutex opencl_device_mutex;
     uint16 opencl_device_private;
 
@@ -372,7 +386,7 @@ typedef struct {
 typedef struct {
   boost::mutex mutex;
   boost::condition condition;
-  std::deque <uint8> fifo;
+  std::deque <int8> fifo;
   uint32 fifo_peak_size;
 } sampbuf_sync_t;
 
diff --git a/src/CellSearch.cpp b/src/CellSearch.cpp
@@ -608,8 +608,8 @@ int config_hackrf(
   double & fs_programmed
 ) {
 
-  unsigned int lna_gain=16; // default value
-  unsigned int vga_gain=60; // default value
+  unsigned int lna_gain=32; // default value
+  unsigned int vga_gain=40; // default value
 
   int result = hackrf_init();
 	if( result != HACKRF_SUCCESS ) {
@@ -943,7 +943,7 @@ int main(
       fci = n_fc_multi_try; // end of loop
       continue;
     }
-//    cout << capbuf(0, 100) << "\n";
+    cout << ( sum( abs(real(capbuf)) )/length(capbuf) ) << "\n";
 
     freq_correction = fc_programmed*(correction-1)/correction;
 //    if (!dongle_used) { // if dongle is not used, do correction explicitly. Because if dongle is used, the correction is done when tuning dongle's frequency.
diff --git a/src/LTE-Tracker.cpp b/src/LTE-Tracker.cpp
@@ -698,8 +698,8 @@ int config_hackrf(
   hackrf_device *& device,
   double & fs_programmed
 ) {
-  unsigned int lna_gain=16; // default value
-  unsigned int vga_gain=60; // default value
+  unsigned int lna_gain=32; // default value
+  unsigned int vga_gain=40; // default value
 
   int result = hackrf_init();
 	if( result != HACKRF_SUCCESS ) {
@@ -1174,25 +1174,25 @@ double kalibrate(
   return best.freq_superfine;
 }
 
+sampbuf_sync_t sampbuf_sync;
+
 #ifdef HAVE_HACKRF
 
 static int hackrf_callback(hackrf_transfer* transfer)
-{
-  sampbuf_sync_t & sampbuf_sync=*((sampbuf_sync_t *)(transfer->rx_ctx));
-
-  //cout << "Callback with " << len << " samples" << endl;
-
+ {
+//  cout << "1\n";
   if (transfer->valid_length==0) {
     cerr << "Error: received no samples from HACKRF device..." << endl;
     ABORT(-1);
   }
 
   boost::mutex::scoped_lock lock(sampbuf_sync.mutex);
   for (uint32 t=0;t<(uint32)transfer->valid_length;t++) {
-    sampbuf_sync.fifo.push_back(transfer->buffer[t]);
+    sampbuf_sync.fifo.push_back((int8)transfer->buffer[t]);
   }
   sampbuf_sync.fifo_peak_size=MAX(sampbuf_sync.fifo.size(),sampbuf_sync.fifo_peak_size);
   sampbuf_sync.condition.notify_one();
+
   return(0);
 }
 
@@ -1214,7 +1214,7 @@ static void rtlsdr_callback(
 
   boost::mutex::scoped_lock lock(sampbuf_sync.mutex);
   for (uint32 t=0;t<len;t++) {
-    sampbuf_sync.fifo.push_back(buf[t]);
+    sampbuf_sync.fifo.push_back(buf[t]-128);
   }
   sampbuf_sync.fifo_peak_size=MAX(sampbuf_sync.fifo.size(),sampbuf_sync.fifo_peak_size);
   sampbuf_sync.condition.notify_one();
@@ -1305,8 +1305,32 @@ int main(
   double initial_k_factor = 1;
   double initial_freq_offset=kalibrate(fc_requested,fs_programmed,ppm,correction,correction_new,use_recorded_data,filename,rtl_sdr_format,noise_power,drop_secs,repeat,dev,hackrf_dev,dev_use,fc_programmed,initial_sampling_carrier_twist,initial_k_factor,record_bin_filename,load_bin_filename,opencl_platform,opencl_device,filter_workitem,xcorr_workitem,num_reserve);
 
+//  // ---------------- stop and close hackrf
+//  Real_Timer tt;
+//  tt.tic();
+//  while(tt.get_time()<2) {;}
+//  if ( dev_use == dev_type_t::HACKRF ) {
+//  #ifdef HAVE_HACKRF
+//    int result = hackrf_stop_rx(hackrf_dev);
+//    if( result != HACKRF_SUCCESS ) {
+//      printf("hackrf_stop_rx() failed: %s (%d)\n", hackrf_error_name((hackrf_error)result), result);
+//      ABORT(-1);
+//    }
+//    result = hackrf_close(hackrf_dev);
+//    if( result != HACKRF_SUCCESS ) {
+//      printf("hackrf_close() failed: %s (%d)\n", hackrf_error_name((hackrf_error)result), result);
+//      ABORT(-1);
+//    }
+//    result = hackrf_exit();
+//    if( result != HACKRF_SUCCESS ) {
+//      printf("hackrf_exit() failed: %s (%d)\n", hackrf_error_name((hackrf_error)result), result);
+//      ABORT(-1);
+//    }
+//  #endif
+//  }
+
   // Data shared between threads
-  sampbuf_sync_t sampbuf_sync;
+//  sampbuf_sync_t sampbuf_sync;
   tracked_cell_list_t tracked_cell_list;
   capbuf_sync_t capbuf_sync;
   global_thread_data_t global_thread_data(fc_requested,fc_programmed,fs_programmed);
@@ -1322,6 +1346,8 @@ int main(
   global_thread_data.frequency_offset(initial_freq_offset);
   global_thread_data.initial_frequency_offset(initial_freq_offset);
 
+  global_thread_data.dev_use(dev_use);
+
   global_thread_data.k_factor(initial_k_factor);
   global_thread_data.correction(correction_new);
   global_thread_data.sampling_carrier_twist(initial_sampling_carrier_twist);
@@ -1363,8 +1389,10 @@ int main(
 //        for (uint32 t=0;t<192000;t++) {
         for (uint32 t=0;t<(uint32)( file_data.length() );t++) {
           complex <double> samp=file_data[offset]+randn_c()*sqrt(noise_power);
-          uint8 samp_real=RAIL(round_i(real(samp)*128.0+128.0),0,255); // 127 should be 128?
-          uint8 samp_imag=RAIL(round_i(imag(samp)*128.0+128.0),0,255); // 127 should be 128?
+//          uint8 samp_real=RAIL(round_i(real(samp)*128.0+128.0),0,255); // 127 should be 128?
+//          uint8 samp_imag=RAIL(round_i(imag(samp)*128.0+128.0),0,255); // 127 should be 128?
+          int8 samp_real=round_i(real(samp)*128.0); // 127 should be 128?
+          int8 samp_imag=round_i(imag(samp)*128.0); // 127 should be 128?
           sampbuf_sync.fifo.push_back(samp_real);
           sampbuf_sync.fifo.push_back(samp_imag);
           offset++;
@@ -1394,32 +1422,58 @@ int main(
       // Start the async read process. This should never return.
       rtlsdr_read_async(dev,rtlsdr_callback,(void *)&sampbuf_sync,0,0);
     } else if (dev_use == dev_type_t::HACKRF) {
-      #ifdef HAVE_HACKRF
-
-      int result = hackrf_stop_rx(hackrf_dev);
-      if( result != HACKRF_SUCCESS ) {
-        printf("hackrf_stop_rx() failed: %s (%d)\n", hackrf_error_name((hackrf_error)result), result);
-        ABORT(-1);
-      }
-
-      result = hackrf_start_rx(hackrf_dev, hackrf_callback, (void *)&sampbuf_sync);
-
-      if( result != HACKRF_SUCCESS ) {
-        printf("hackrf_start_rx() failed: %s (%d)\n", hackrf_error_name((hackrf_error)result), result);
-        ABORT(-1);
+      cvec capbuf;
+      while(1) {
+        capture_data(fc_requested,correction,false,record_bin_filename,use_recorded_data,load_bin_filename,".",dev,hackrf_dev, dev_use,capbuf,fc_programmed,fs_programmed,false);
+//        cout << "cap\n";
+        boost::mutex::scoped_lock lock(sampbuf_sync.mutex);
+        for (uint32 t=0;t<(uint32)length(capbuf);t++) {
+          sampbuf_sync.fifo.push_back( (int8)(round_i( real( capbuf[t] )*128) ) );
+          sampbuf_sync.fifo.push_back( (int8)(round_i( imag( capbuf[t] )*128) ) );
+        }
+        sampbuf_sync.fifo_peak_size=MAX(sampbuf_sync.fifo.size(),sampbuf_sync.fifo_peak_size);
+        sampbuf_sync.condition.notify_one();
       }
+//      #ifdef HAVE_HACKRF
+//
+//      tt.tic();
+//      while(tt.get_time()<10) {;}
+//      if ( config_hackrf(initial_sampling_carrier_twist,correction,device_index,fc_requested,hackrf_dev,fs_programmed) != 0 ) {
+//        cout << "HACKRF re-config failed!\n";
+//      }
+//      int result;
+//      result = hackrf_stop_rx(hackrf_dev);
+//      if( result != HACKRF_SUCCESS ) {
+//        printf("hackrf_stop_rx() failed: %s (%d)\n", hackrf_error_name((hackrf_error)result), result);
+//        ABORT(-1);
+//      }
+//
+//      result = hackrf_start_rx(hackrf_dev, hackrf_callback, NULL);
+//
+//      if( result != HACKRF_SUCCESS ) {
+//        printf("hackrf_start_rx() failed: %s (%d)\n", hackrf_error_name((hackrf_error)result), result);
+//        ABORT(-1);
+//      }
+//
+////      while(1);
+//      int tmp_count=0;
+//
+//      result = hackrf_is_streaming(hackrf_dev);
+//      printf("hackrf_is_streaming() failed: %s (%d)\n", hackrf_error_name((hackrf_error)result), result);
+//
+//      while(hackrf_is_streaming(hackrf_dev) == HACKRF_TRUE) {
+//        cout << (++tmp_count) << "\n";
+//      }
+//
+//      cout << "HACKRF streaming exit abnormally!\n";
+//      ABORT(-1);
 
-      while(hackrf_is_streaming(hackrf_dev) == HACKRF_TRUE) {;}
-
-      cout << "HACKRF streaming exit abnormally!\n";
-      ABORT(-1);
-
-      #else
-
-      cout << "HACKRF can't be used when lib is not included!\n";
-      ABORT(-1);
-
-      #endif
+//      #else
+//
+//      cout << "HACKRF can't be used when lib is not included!\n";
+//      ABORT(-1);
+//
+//      #endif
 
     } else {
       cout << "No valid device present.\n";
diff --git a/src/capbuf.cpp b/src/capbuf.cpp
@@ -372,7 +372,7 @@ int capture_data(
     unsigned char *capbuf_raw = new unsigned char[2*CAPLENGTH];
 
     if (read_all_in_bin) {
-      capbuf.set_size(0);
+      capbuf.set_size(0, false);
 
       FILE *fp = fopen(load_bin_filename, "rb");
       if (fp == NULL)
@@ -408,7 +408,7 @@ int capture_data(
 
       fclose(fp);
     } else {
-      capbuf.set_size(CAPLENGTH);
+      capbuf.set_size(CAPLENGTH, false);
 
       FILE *fp = fopen(load_bin_filename, "rb");
       if (fp == NULL)
@@ -508,7 +508,7 @@ int capture_data(
       rtlsdr_read_async(dev,capbuf_rtlsdr_callback,(void *)&cp,0,0);
 
       // Convert to complex
-      capbuf.set_size(CAPLENGTH);
+      capbuf.set_size(CAPLENGTH, false);
   #ifndef NDEBUG
       capbuf=NAN;
   #endif
@@ -566,7 +566,7 @@ int capture_data(
 //      }
 
       // Convert to complex
-      capbuf.set_size(CAPLENGTH);
+      capbuf.set_size(CAPLENGTH, false);
       for (uint32 t=0;t<CAPLENGTH;t++) {
 //        capbuf(t)=complex<double>((((double)hackrf_rx_buf[(t<<1)])-128.0)/128.0,(((double)hackrf_rx_buf[(t<<1)+1])-128.0)/128.0);
         capbuf(t)=complex<double>((((double)hackrf_rx_buf[(t<<1)])-0.0)/128.0,(((double)hackrf_rx_buf[(t<<1)+1])-0.0)/128.0);
diff --git a/src/producer_thread.cpp b/src/producer_thread.cpp
@@ -101,10 +101,12 @@ void producer_thread(
     const double frequency_offset=global_thread_data.frequency_offset();
     double k_factor = 1.0; // if not twisted, make k_factor useless
 
-    if (global_thread_data.sampling_carrier_twist()){
-      k_factor=(global_thread_data.fc_programmed-frequency_offset)/global_thread_data.fc_programmed;
-    } else {
-      k_factor=global_thread_data.k_factor(); // !!!!!!BE CAREFUL OF UPDATING K_FACTOR IN NON-TWIST MODE
+    if (global_thread_data.dev_use()!=dev_type_t::HACKRF) {
+      if (global_thread_data.sampling_carrier_twist()){
+        k_factor=(global_thread_data.fc_programmed-frequency_offset)/global_thread_data.fc_programmed;
+      } else {
+        k_factor=global_thread_data.k_factor(); // !!!!!!BE CAREFUL OF UPDATING K_FACTOR IN NON-TWIST MODE
+      }
     }
 
     //const double k_factor_inv=1/k_factor;
@@ -134,9 +136,9 @@ void producer_thread(
           n_samples=t;
           break;
         }
-        sample_temp.real()=(sampbuf_sync.fifo.front()-128.0)/128.0; // 127 should be 128?
+        sample_temp.real()=(sampbuf_sync.fifo.front())/128.0; // 127 should be 128?
         sampbuf_sync.fifo.pop_front();
-        sample_temp.imag()=(sampbuf_sync.fifo.front()-128.0)/128.0; // 127 should be 128?
+        sample_temp.imag()=(sampbuf_sync.fifo.front())/128.0; // 127 should be 128?
         sampbuf_sync.fifo.pop_front();
         samples(t)=sample_temp;
         sample_time+=(FS_LTE/16)/(fs_programmed*k_factor);
diff --git a/src/searcher.cpp b/src/searcher.cpp
@@ -2312,7 +2312,7 @@ void sampling_ppm_f_search_set_by_pss(
 
   ivec sort_idx = sort_index(max_peak_all);
   sort_idx = reverse(sort_idx); // from ascending to descending
-  DBG( cout << "Hit        PAR " << 10.0*log10( peak_to_avg.get( sort_idx(0, max_reserve-1) ) ) << "dB\n"; )
+  cout << "Hit        PAR " << 10.0*log10( peak_to_avg.get( sort_idx(0, max_reserve-1) ) ) << "dB\n";
 
   ivec above_par_idx = to_ivec( peak_to_avg.get( sort_idx(0, max_reserve-1) ) > pow(10.0, 8.5/10.0) );
   uint16 len_sort_idx = sum(above_par_idx);
