Add more extensive use of cstdint typenames

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc

@@ -268,7 +268,7 @@ void pcps_acquisition::init()
     d_mag = 0.0;
     d_input_power = 0.0;
 
-    d_num_doppler_bins = static_cast<uint32_t>(std::ceil(static_cast<double>(static_cast<int>(acq_parameters.doppler_max) - static_cast<int>(-acq_parameters.doppler_max)) / static_cast<double>(d_doppler_step)));
+    d_num_doppler_bins = static_cast<uint32_t>(std::ceil(static_cast<double>(static_cast<int32_t>(acq_parameters.doppler_max) - static_cast<int32_t>(-acq_parameters.doppler_max)) / static_cast<double>(d_doppler_step)));
 
     // Create the carrier Doppler wipeoff signals
     d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins];
@@ -290,7 +290,7 @@ void pcps_acquisition::init()
                 {
                     d_magnitude_grid[doppler_index][k] = 0.0;
                 }
-            int32_t doppler = -static_cast<int>(acq_parameters.doppler_max) + d_doppler_step * doppler_index;
+            int32_t doppler = -static_cast<int32_t>(acq_parameters.doppler_max) + d_doppler_step * doppler_index;
             update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_old_freq + doppler);
         }
 
@@ -309,7 +309,7 @@ void pcps_acquisition::update_grid_doppler_wipeoffs()
 {
     for (uint32_t doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
         {
-            int32_t doppler = -static_cast<int>(acq_parameters.doppler_max) + d_doppler_step * doppler_index;
+            int32_t doppler = -static_cast<int32_t>(acq_parameters.doppler_max) + d_doppler_step * doppler_index;
             update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_old_freq + doppler);
         }
 }
@@ -510,11 +510,11 @@ float pcps_acquisition::max_to_input_power_statistic(uint32_t& indext, int32_t&
     indext = index_time;
     if (!d_step_two)
         {
-            doppler = -static_cast<int>(doppler_max) + doppler_step * static_cast<int>(index_doppler);
+            doppler = -static_cast<int32_t>(doppler_max) + doppler_step * static_cast<int32_t>(index_doppler);
         }
     else
         {
-            doppler = static_cast<int>(d_doppler_center_step_two + (static_cast<float>(index_doppler) - static_cast<float>(floor(d_num_doppler_bins_step2 / 2.0))) * acq_parameters.doppler_step2);
+            doppler = static_cast<int32_t>(d_doppler_center_step_two + (static_cast<float>(index_doppler) - static_cast<float>(floor(d_num_doppler_bins_step2 / 2.0))) * acq_parameters.doppler_step2);
         }
 
     float magt = grid_maximum / (fft_normalization_factor * fft_normalization_factor);
@@ -548,11 +548,11 @@ float pcps_acquisition::first_vs_second_peak_statistic(uint32_t& indext, int32_t
 
     if (!d_step_two)
         {
-            doppler = -static_cast<int>(doppler_max) + doppler_step * static_cast<int>(index_doppler);
+            doppler = -static_cast<int32_t>(doppler_max) + doppler_step * static_cast<int32_t>(index_doppler);
         }
     else
         {
-            doppler = static_cast<int>(d_doppler_center_step_two + (static_cast<float>(index_doppler) - static_cast<float>(floor(d_num_doppler_bins_step2 / 2.0))) * acq_parameters.doppler_step2);
+            doppler = static_cast<int32_t>(d_doppler_center_step_two + (static_cast<float>(index_doppler) - static_cast<float>(floor(d_num_doppler_bins_step2 / 2.0))) * acq_parameters.doppler_step2);
         }
 
     // Find 1 chip wide code phase exclude range around the peak
@@ -564,7 +564,7 @@ float pcps_acquisition::first_vs_second_peak_statistic(uint32_t& indext, int32_t
         {
             excludeRangeIndex1 = d_fft_size + excludeRangeIndex1;
         }
-    else if (excludeRangeIndex2 >= static_cast<int>(d_fft_size))
+    else if (excludeRangeIndex2 >= static_cast<int32_t>(d_fft_size))
         {
             excludeRangeIndex2 = excludeRangeIndex2 - d_fft_size;
         }
@@ -575,7 +575,7 @@ float pcps_acquisition::first_vs_second_peak_statistic(uint32_t& indext, int32_t
         {
             d_tmp_buffer[idx] = 0.0;
             idx++;
-            if (idx == static_cast<int>(d_fft_size)) idx = 0;
+            if (idx == static_cast<int32_t>(d_fft_size)) idx = 0;
         }
     while (idx != excludeRangeIndex2);
 
@@ -716,11 +716,11 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count)
             // Compute the test statistic
             if (d_use_CFAR_algorithm_flag)
                 {
-                    d_test_statistics = max_to_input_power_statistic(indext, doppler, d_input_power, d_num_doppler_bins_step2, static_cast<int>(d_doppler_center_step_two - (static_cast<float>(d_num_doppler_bins_step2) / 2.0) * acq_parameters.doppler_step2), acq_parameters.doppler_step2);
+                    d_test_statistics = max_to_input_power_statistic(indext, doppler, d_input_power, d_num_doppler_bins_step2, static_cast<int32_t>(d_doppler_center_step_two - (static_cast<float>(d_num_doppler_bins_step2) / 2.0) * acq_parameters.doppler_step2), acq_parameters.doppler_step2);
                 }
             else
                 {
-                    d_test_statistics = first_vs_second_peak_statistic(indext, doppler, d_num_doppler_bins_step2, static_cast<int>(d_doppler_center_step_two - (static_cast<float>(d_num_doppler_bins_step2) / 2.0) * acq_parameters.doppler_step2), acq_parameters.doppler_step2);
+                    d_test_statistics = first_vs_second_peak_statistic(indext, doppler, d_num_doppler_bins_step2, static_cast<int32_t>(d_doppler_center_step_two - (static_cast<float>(d_num_doppler_bins_step2) / 2.0) * acq_parameters.doppler_step2), acq_parameters.doppler_step2);
                 }
             d_gnss_synchro->Acq_delay_samples = static_cast<double>(std::fmod(static_cast<float>(indext), acq_parameters.samples_per_code));
             d_gnss_synchro->Acq_doppler_hz = static_cast<double>(doppler);
@@ -844,7 +844,7 @@ int pcps_acquisition::general_work(int noutput_items __attribute__((unused)),
         {
             if (!acq_parameters.blocking_on_standby)
                 {
-                    d_sample_counter += ninput_items[0];
+                    d_sample_counter += static_cast<uint64_t>(ninput_items[0]);
                     consume_each(ninput_items[0]);
                 }
             if (d_step_two)
@@ -872,7 +872,7 @@ int pcps_acquisition::general_work(int noutput_items __attribute__((unused)),
                 d_buffer_count = 0;
                 if (!acq_parameters.blocking_on_standby)
                     {
-                        d_sample_counter += ninput_items[0];  // sample counter
+                        d_sample_counter += static_cast<uint64_t>(ninput_items[0]);  // sample counter
                         consume_each(ninput_items[0]);
                     }
                 break;
@@ -913,7 +913,7 @@ int pcps_acquisition::general_work(int noutput_items __attribute__((unused)),
                         d_state = 2;
                     }
                 d_buffer_count += buff_increment;
-                d_sample_counter += buff_increment;
+                d_sample_counter += static_cast<uint64_t>(buff_increment);
                 consume_each(buff_increment);
                 break;
             }

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.h

@@ -64,13 +64,13 @@
 typedef struct
 {
     /* pcps acquisition configuration */
-    unsigned int sampled_ms;
+    uint32_t sampled_ms;
-    unsigned int doppler_max;
+    uint32_t doppler_max;
-    long freq;
+    int64_t freq;
-    long fs_in;
+    int64_t fs_in;
-    int samples_per_ms;
+    int32_tsamples_per_ms;
-    int samples_per_code;
+    int32_tsamples_per_code;
-    unsigned int select_queue_Fpga;
+    uint32_t select_queue_Fpga;
     std::string device_name;
     lv_16sc_t* all_fft_codes;  // memory that contains all the code ffts
 
@@ -108,11 +108,11 @@ private:
     float d_mag;
     float d_input_power;
     float d_test_statistics;
-    int d_state;
+    int32_td_state;
-    unsigned int d_channel;
+    uint32_t d_channel;
-    unsigned int d_doppler_step;
+    uint32_t d_doppler_step;
-    unsigned int d_fft_size;
+    uint32_t d_fft_size;
-    unsigned int d_num_doppler_bins;
+    uint32_t d_num_doppler_bins;
     uint64_t d_sample_counter;
     Gnss_Synchro* d_gnss_synchro;
     std::shared_ptr<fpga_acquisition> acquisition_fpga;
@@ -133,7 +133,7 @@ public:
     /*!
      * \brief Returns the maximum peak of grid search.
      */
-    inline unsigned int mag() const
+    inline uint32_t mag() const
     {
         return d_mag;
     }
@@ -154,7 +154,7 @@ public:
       * first available sample.
       * \param state - int=1 forces start of acquisition
       */
-    void set_state(int state);
+    void set_state(int32_tstate);
 
     /*!
       * \brief Starts acquisition algorithm, turning from standby mode to
@@ -167,7 +167,7 @@ public:
       * \brief Set acquisition channel unique ID
       * \param channel - receiver channel.
       */
-    inline void set_channel(unsigned int channel)
+    inline void set_channel(uint32_t channel)
     {
         d_channel = channel;
     }
@@ -186,7 +186,7 @@ public:
       * \brief Set maximum Doppler grid search
       * \param doppler_max - Maximum Doppler shift considered in the grid search [Hz].
       */
-    inline void set_doppler_max(unsigned int doppler_max)
+    inline void set_doppler_max(uint32_t doppler_max)
     {
         acq_parameters.doppler_max = doppler_max;
         acquisition_fpga->set_doppler_max(doppler_max);
@@ -196,7 +196,7 @@ public:
       * \brief Set Doppler steps for the grid search
       * \param doppler_step - Frequency bin of the search grid [Hz].
       */
-    inline void set_doppler_step(unsigned int doppler_step)
+    inline void set_doppler_step(uint32_t doppler_step)
     {
         d_doppler_step = doppler_step;
         acquisition_fpga->set_doppler_step(doppler_step);

src/algorithms/acquisition/libs/fpga_acquisition.cc

@@ -64,7 +64,7 @@ bool fpga_acquisition::init()
 }
 
 
-bool fpga_acquisition::set_local_code(unsigned int PRN)
+bool fpga_acquisition::set_local_code(uint32_t PRN)
 {
     // select the code with the chosen PRN
     fpga_acquisition::fpga_configure_acquisition_local_code(
@@ -74,13 +74,13 @@ bool fpga_acquisition::set_local_code(unsigned int PRN)
 
 
 fpga_acquisition::fpga_acquisition(std::string device_name,
-    unsigned int nsamples,
+    uint32_t nsamples,
-    unsigned int doppler_max,
+    uint32_t doppler_max,
-    unsigned int nsamples_total, long fs_in,
+    uint32_t nsamples_total, int64_t fs_in,
-    unsigned int sampled_ms, unsigned select_queue,
+    uint32_t sampled_ms, uint32_t select_queue,
     lv_16sc_t *all_fft_codes)
 {
-    unsigned int vector_length = nsamples_total * sampled_ms;
+    uint32_t vector_length = nsamples_total * sampled_ms;
     // initial values
     d_device_name = device_name;
     d_fs_in = fs_in;
@@ -99,7 +99,7 @@ fpga_acquisition::fpga_acquisition(std::string device_name,
         {
             LOG(WARNING) << "Cannot open deviceio" << d_device_name;
         }
-    d_map_base = reinterpret_cast<volatile unsigned *>(mmap(NULL, PAGE_SIZE,
+    d_map_base = reinterpret_cast<volatile uint32_t *>(mmap(NULL, PAGE_SIZE,
         PROT_READ | PROT_WRITE, MAP_SHARED, d_fd, 0));
 
     if (d_map_base == reinterpret_cast<void *>(-1))
@@ -108,8 +108,8 @@ fpga_acquisition::fpga_acquisition(std::string device_name,
         }
 
     // sanity check : check test register
-    unsigned writeval = TEST_REG_SANITY_CHECK;
+    uint32_t writeval = TEST_REG_SANITY_CHECK;
-    unsigned readval;
+    uint32_t readval;
     readval = fpga_acquisition::fpga_acquisition_test_register(writeval);
     if (writeval != readval)
         {
@@ -136,9 +136,9 @@ bool fpga_acquisition::free()
 }
 
 
-unsigned fpga_acquisition::fpga_acquisition_test_register(unsigned writeval)
+uint32_t fpga_acquisition::fpga_acquisition_test_register(uint32_t writeval)
 {
-    unsigned readval;
+    uint32_t readval;
     // write value to test register
     d_map_base[15] = writeval;
     // read value from test register
@@ -150,9 +150,9 @@ unsigned fpga_acquisition::fpga_acquisition_test_register(unsigned writeval)
 
 void fpga_acquisition::fpga_configure_acquisition_local_code(lv_16sc_t fft_local_code[])
 {
-    unsigned short local_code;
+    uint16_t local_code;
-    unsigned int k, tmp, tmp2;
+    uint32_t k, tmp, tmp2;
-    unsigned int fft_data;
+    uint32_t fft_data;
     // clear memory address counter
     d_map_base[4] = LOCAL_CODE_CLEAR_MEM;
     // write local code
@@ -170,12 +170,12 @@ void fpga_acquisition::fpga_configure_acquisition_local_code(lv_16sc_t fft_local
 void fpga_acquisition::run_acquisition(void)
 {
     // enable interrupts
-    int reenable = 1;
+    int32_t reenable = 1;
-    write(d_fd, reinterpret_cast<void *>(&reenable), sizeof(int));
+    write(d_fd, reinterpret_cast<void *>(&reenable), sizeof(int32_t));
     // launch the acquisition process
     d_map_base[6] = LAUNCH_ACQUISITION;  // writing anything to reg 6 launches the acquisition process
 
-    int irq_count;
+    int32_t irq_count;
     ssize_t nb;
     // wait for interrupt
     nb = read(d_fd, &irq_count, sizeof(irq_count));
@@ -192,16 +192,16 @@ void fpga_acquisition::configure_acquisition()
     d_map_base[0] = d_select_queue;
     d_map_base[1] = d_vector_length;
     d_map_base[2] = d_nsamples;
-    d_map_base[5] = (int)log2((float)d_vector_length);  // log2 FFTlength
+    d_map_base[5] = static_cast<int32_t>(log2(static_cast<float>(d_vector_length)));  // log2 FFTlength
 }
 
 
-void fpga_acquisition::set_phase_step(unsigned int doppler_index)
+void fpga_acquisition::set_phase_step(uint32_t doppler_index)
 {
     float phase_step_rad_real;
     float phase_step_rad_int_temp;
     int32_t phase_step_rad_int;
-    int doppler = static_cast<int>(-d_doppler_max) + d_doppler_step * doppler_index;
+    int32_t doppler = static_cast<int>(-d_doppler_max) + d_doppler_step * doppler_index;
     float phase_step_rad = GPS_TWO_PI * doppler / static_cast<float>(d_fs_in);
     // The doppler step can never be outside the range -pi to +pi, otherwise there would be aliasing
     // The FPGA expects phase_step_rad between -1 (-pi) to +1 (+pi)
@@ -221,9 +221,9 @@ void fpga_acquisition::set_phase_step(unsigned int doppler_index)
 
 
 void fpga_acquisition::read_acquisition_results(uint32_t *max_index,
-    float *max_magnitude, unsigned *initial_sample, float *power_sum)
+    float *max_magnitude, uint32_t *initial_sample, float *power_sum)
 {
-    unsigned readval = 0;
+    uint32_t readval = 0;
     readval = d_map_base[1];
     *initial_sample = readval;
     readval = d_map_base[2];
@@ -249,7 +249,7 @@ void fpga_acquisition::unblock_samples()
 
 void fpga_acquisition::close_device()
 {
-    unsigned *aux = const_cast<unsigned *>(d_map_base);
+    uint32_t *aux = const_cast<uint32_t *>(d_map_base);
     if (munmap(static_cast<void *>(aux), PAGE_SIZE) == -1)
         {
             printf("Failed to unmap memory uio\n");

src/algorithms/acquisition/libs/fpga_acquisition.h

@@ -38,6 +38,7 @@
 
 #include <gnuradio/fft/fft.h>
 #include <volk/volk.h>
+#include <cstdint>
 
 /*!
  * \brief Class that implements carrier wipe-off and correlators.
@@ -46,20 +47,22 @@ class fpga_acquisition
 {
 public:
     fpga_acquisition(std::string device_name,
-        unsigned int nsamples,
+        uint32_t nsamples,
-        unsigned int doppler_max,
+        uint32_t doppler_max,
-        unsigned int nsamples_total, long fs_in,
+        uint32_t nsamples_total,
-        unsigned int sampled_ms, unsigned select_queue,
+        int64_t fs_in,
+        uint32_t sampled_ms,
+        uint32_t select_queue,
         lv_16sc_t *all_fft_codes);
+
     ~fpga_acquisition();
     bool init();
-    bool set_local_code(
+    bool set_local_code(uint32_t PRN);
-        unsigned int PRN);
     bool free();
     void run_acquisition(void);
-    void set_phase_step(unsigned int doppler_index);
+    void set_phase_step(uint32_t doppler_index);
     void read_acquisition_results(uint32_t *max_index, float *max_magnitude,
-        unsigned *initial_sample, float *power_sum);
+        uint32_t *initial_sample, float *power_sum);
     void block_samples();
     void unblock_samples();
 
@@ -67,7 +70,7 @@ public:
      * \brief Set maximum Doppler grid search
      * \param doppler_max - Maximum Doppler shift considered in the grid search [Hz].
      */
-    void set_doppler_max(unsigned int doppler_max)
+    void set_doppler_max(uint32_t doppler_max)
     {
         d_doppler_max = doppler_max;
     }
@@ -76,26 +79,26 @@ public:
      * \brief Set Doppler steps for the grid search
      * \param doppler_step - Frequency bin of the search grid [Hz].
      */
-    void set_doppler_step(unsigned int doppler_step)
+    void set_doppler_step(uint32_t doppler_step)
     {
         d_doppler_step = doppler_step;
     }
 
 private:
-    long d_fs_in;
+    int64_t d_fs_in;
     // data related to the hardware module and the driver
-    int d_fd;                       // driver descriptor
+    int32_t d_fd;                   // driver descriptor
-    volatile unsigned *d_map_base;  // driver memory map
+    volatile uint32_t *d_map_base;  // driver memory map
     lv_16sc_t *d_all_fft_codes;     // memory that contains all the code ffts
-    unsigned int d_vector_length;   // number of samples incluing padding and number of ms
+    uint32_t d_vector_length;       // number of samples incluing padding and number of ms
-    unsigned int d_nsamples_total;  // number of samples including padding
+    uint32_t d_nsamples_total;      // number of samples including padding
-    unsigned int d_nsamples;        // number of samples not including padding
+    uint32_t d_nsamples;            // number of samples not including padding
-    unsigned int d_select_queue;    // queue selection
+    uint32_t d_select_queue;        // queue selection
     std::string d_device_name;      // HW device name
-    unsigned int d_doppler_max;     // max doppler
+    uint32_t d_doppler_max;         // max doppler
-    unsigned int d_doppler_step;    // doppler step
+    uint32_t d_doppler_step;        // doppler step
     // FPGA private functions
-    unsigned fpga_acquisition_test_register(unsigned writeval);
+    uint32_t fpga_acquisition_test_register(uint32_t writeval);
     void fpga_configure_acquisition_local_code(lv_16sc_t fft_local_code[]);
     void configure_acquisition();
     void reset_acquisition(void);