Package de.serosystems.proto.v3.grx.spectrumd

Interface SpectrumDProto.AggregatedFFTBlockOrBuilder

All Superinterfaces:
com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder
All Known Implementing Classes:
SpectrumDProto.AggregatedFFTBlock, SpectrumDProto.AggregatedFFTBlock.Builder
Enclosing class:
SpectrumDProto
public static interface SpectrumDProto.AggregatedFFTBlockOrBuilder extends com.google.protobuf.MessageOrBuilder

  • Method Summary

    Modifier and Type
    Method
    Description
    float
    getBinsAvg(int index)
    Averaged FFT bins [dBm].
    int
    getBinsAvgCount()
    Averaged FFT bins [dBm].
    List<Float>
    getBinsAvgList()
    Averaged FFT bins [dBm].
    float
    getBinsPeak(int index)
    Aggregated (peak=max) FFT bins [dBm].
    int
    getBinsPeakCount()
    Aggregated (peak=max) FFT bins [dBm].
    List<Float>
    getBinsPeakList()
    Aggregated (peak=max) FFT bins [dBm].

    Methods inherited from interface com.google.protobuf.MessageLiteOrBuilder

    isInitialized

    Methods inherited from interface com.google.protobuf.MessageOrBuilder

    findInitializationErrors, getAllFields, getDefaultInstanceForType, getDescriptorForType, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof

  • Method Details

    • getBinsAvgList

      List<Float> getBinsAvgList()
      
 Averaged FFT bins [dBm].
 Each bin has bandwidth (sample_rate / fft_size) and is averaged over
  a duration of (aggregation_factor * fft_size / sample_rate).
 The FFT bins are centered around center_frequency, i.e.
  first element corresponds to (center_frequency - 0.5 * sample_rate),
  last element corresponds to
   (center_frequency + (0.5 - 1/fft_size) * sample_rate),
  and the center frequency is found at index (fft_size/2).
 The number of FFT bins is fixed to (fft_size).
      repeated float bins_avg = 1;
      Returns:
      A list containing the binsAvg.

    • getBinsAvgCount

      int getBinsAvgCount()
      
 Averaged FFT bins [dBm].
 Each bin has bandwidth (sample_rate / fft_size) and is averaged over
  a duration of (aggregation_factor * fft_size / sample_rate).
 The FFT bins are centered around center_frequency, i.e.
  first element corresponds to (center_frequency - 0.5 * sample_rate),
  last element corresponds to
   (center_frequency + (0.5 - 1/fft_size) * sample_rate),
  and the center frequency is found at index (fft_size/2).
 The number of FFT bins is fixed to (fft_size).
      repeated float bins_avg = 1;
      Returns:
      The count of binsAvg.

    • getBinsAvg

      float getBinsAvg(int index)
      
 Averaged FFT bins [dBm].
 Each bin has bandwidth (sample_rate / fft_size) and is averaged over
  a duration of (aggregation_factor * fft_size / sample_rate).
 The FFT bins are centered around center_frequency, i.e.
  first element corresponds to (center_frequency - 0.5 * sample_rate),
  last element corresponds to
   (center_frequency + (0.5 - 1/fft_size) * sample_rate),
  and the center frequency is found at index (fft_size/2).
 The number of FFT bins is fixed to (fft_size).
      repeated float bins_avg = 1;
      Parameters:
      index - The index of the element to return.
      Returns:
      The binsAvg at the given index.

    • getBinsPeakList

      List<Float> getBinsPeakList()
      
 Aggregated (peak=max) FFT bins [dBm].
 Each bin has bandwidth (sample_rate / fft_size) and is the maximum
  observed over a duration of
  (aggregation_factor * fft_size / sample_rate).
 The FFT bins are centered around center_frequency, i.e.
  first element corresponds to center_frequency - 0.5 * sample_rate,
  last element corresponds to
   (center_frequency + (0.5 - 1/fft_size) * sample_rate),
  and the center frequency is found at index (fft_size/2).
 The number of FFT bins is fixed to fft_size.

 Important note: intermediate peak results are highly compressed (using a
  logarithmic representation), thus you will almost certainly note
  "steps" in the data. Small values might be smaller than the average
  values or they might even be -inf, due to a low resolution for low
  values.
  In such cases, the average value represents a "better" peak.
  This should not be an issue for strong signals, though.
      repeated float bins_peak = 2;
      Returns:
      A list containing the binsPeak.

    • getBinsPeakCount

      int getBinsPeakCount()
      
 Aggregated (peak=max) FFT bins [dBm].
 Each bin has bandwidth (sample_rate / fft_size) and is the maximum
  observed over a duration of
  (aggregation_factor * fft_size / sample_rate).
 The FFT bins are centered around center_frequency, i.e.
  first element corresponds to center_frequency - 0.5 * sample_rate,
  last element corresponds to
   (center_frequency + (0.5 - 1/fft_size) * sample_rate),
  and the center frequency is found at index (fft_size/2).
 The number of FFT bins is fixed to fft_size.

 Important note: intermediate peak results are highly compressed (using a
  logarithmic representation), thus you will almost certainly note
  "steps" in the data. Small values might be smaller than the average
  values or they might even be -inf, due to a low resolution for low
  values.
  In such cases, the average value represents a "better" peak.
  This should not be an issue for strong signals, though.
      repeated float bins_peak = 2;
      Returns:
      The count of binsPeak.

    • getBinsPeak

      float getBinsPeak(int index)
      
 Aggregated (peak=max) FFT bins [dBm].
 Each bin has bandwidth (sample_rate / fft_size) and is the maximum
  observed over a duration of
  (aggregation_factor * fft_size / sample_rate).
 The FFT bins are centered around center_frequency, i.e.
  first element corresponds to center_frequency - 0.5 * sample_rate,
  last element corresponds to
   (center_frequency + (0.5 - 1/fft_size) * sample_rate),
  and the center frequency is found at index (fft_size/2).
 The number of FFT bins is fixed to fft_size.

 Important note: intermediate peak results are highly compressed (using a
  logarithmic representation), thus you will almost certainly note
  "steps" in the data. Small values might be smaller than the average
  values or they might even be -inf, due to a low resolution for low
  values.
  In such cases, the average value represents a "better" peak.
  This should not be an issue for strong signals, though.
      repeated float bins_peak = 2;
      Parameters:
      index - The index of the element to return.
      Returns:
      The binsPeak at the given index.