def start(self):
self._bounds = self._Reader.get_bounds(self._ch)
self._start_sample = util.parse_identifier_to_sample(
self._start,
self._sample_rate,
self._bounds[0],
)
self._end_sample = util.parse_identifier_to_sample(
self._end,
self._sample_rate,
self._bounds[0],
)
if self._start_sample is None:
self._read_start_sample = self._bounds[0]
else:
self._read_start_sample = self._start_sample
# add default tags to first sample
self._queue_tags(self._read_start_sample, {})
# replace longdouble samples_per_second with float for pmt conversion
properties_message = self._properties.copy()
properties_message['samples_per_second'] = \
float(properties_message['samples_per_second'])
self.message_port_pub(
pmt.intern('properties'),
pmt.to_pmt({self._ch: properties_message}),
)
return super(digital_rf_channel_source, self).start()
def __init__(
self,
channel_dir,
dtype,
subdir_cadence_secs,
file_cadence_millisecs,
sample_rate_numerator,
sample_rate_denominator,
start=None,
ignore_tags=False,
is_complex=True,
num_subchannels=1,
uuid_str=None,
center_frequencies=None,
metadata=None,
is_continuous=True,
compression_level=0,
checksum=False,
marching_periods=True,
stop_on_skipped=False,
stop_on_time_tag=False,
debug=False,
min_chunksize=None,
):
"""Write a channel of data in Digital RF format.
In addition to storing the input samples in Digital RF format, this
block also populates the channel's accompanying Digital Metadata
at the sample indices when the metadata changes or a data skip occurs.
See the Notes section for details on what metadata is stored.
Parameters
----------
channel_dir : string
The directory where this channel is to be written. It will be
created if it does not exist. The basename (last component) of the
path is considered the channel's name for reading purposes.
dtype : np.dtype | object to be cast by np.dtype()
Object that gives the numpy dtype of the data to be written. This
value is passed into ``np.dtype`` to get the actual dtype
(e.g. ``np.dtype('>i4')``). Scalar types, complex types, and
structured complex types with 'r' and 'i' fields of scalar types
are valid.
subdir_cadence_secs : int
The number of seconds of data to store in one subdirectory. The
timestamp of any subdirectory will be an integer multiple of this
value.
file_cadence_millisecs : int
The number of milliseconds of data to store in each file. Note that
an integer number of files must exactly span a subdirectory,
implying::
(subdir_cadence_secs*1000 % file_cadence_millisecs) == 0
sample_rate_numerator : int
Numerator of sample rate in Hz.
sample_rate_denominator : int
Denominator of sample rate in Hz.
Other Parameters
----------------
start : None | int | float | string, optional
A value giving the time/index of the channel's first sample. When
`ignore_tags` is False, 'rx_time' tags will be used to identify
data gaps and skip the sample index forward appropriately (tags
that refer to an earlier time will be ignored).
If None or '' and `ignore_tags` is False, drop data until an
'rx_time' tag arrives and sets the start time (a ValueError is
raised if `ignore_tags` is True).
If an integer, it is interpreted as a sample index given in the
number of samples since the epoch (time_since_epoch*sample_rate).
If a float, it is interpreted as a UTC timestamp (seconds since
epoch).
If a string, three forms are permitted:
1) a string which can be evaluated to an integer/float and
interpreted as above,
2) a time in ISO8601 format, e.g. '2016-01-01T16:24:00Z'
3) 'now' ('nowish'), indicating the current time (rounded up)
ignore_tags : bool, optional
If True, do not use 'rx_time' tags to set the sample index and do
not write other tags as Digital Metadata.
is_complex : bool, optional
This parameter is only used when `dtype` is not complex.
If True (the default), interpret supplied data as interleaved
complex I/Q samples. If False, each sample has a single value.
num_subchannels : int, optional
Number of subchannels to write simultaneously. Default is 1.
uuid_str : None | string, optional
UUID string that will act as a unique identifier for the data and
can be used to tie the data files to metadata. If None, a random
UUID will be generated.
center_frequencies : None | array_like of floats, optional
List of subchannel center frequencies to include in initial
metadata. If None, ``[0.0]*num_subchannels`` will be used.
Subsequent center frequency metadata samples can be written using
'rx_freq' stream tags.
metadata : dict, optional
Dictionary of additional metadata to include in initial Digital
Metadata sample. Subsequent metadata samples can be written
using 'metadata' stream tags, but all keys intended to be included
should be set here first even if their values are empty.
is_continuous : bool, optional
If True, data will be written in continuous blocks. If False data
will be written with gapped blocks. Fastest write/read speed is
achieved with `is_continuous` True, `checksum` False, and
`compression_level` 0 (all defaults).
compression_level : int, optional
0 for no compression (default), 1-9 for varying levels of gzip
compression (1 == least compression, least CPU; 9 == most
compression, most CPU).
checksum : bool, optional
If True, use HDF5 checksum capability. If False (default), no
checksum.
marching_periods : bool, optional
If True, write a period to stdout for every subdirectory when
writing.
stop_on_skipped : bool, optional
If True, stop writing when a sample would be skipped (such as from
a dropped packet).
stop_on_time_tag : bool, optional
If True, stop writing when any but an initial 'rx_time' tag is received.
debug : bool, optional
If True, print debugging information.
min_chunksize : None | int, optional
Minimum number of samples to consume at once. This value can be
used to adjust the sink's performance to reduce processing time.
If None, a sensible default will be used.
Notes
-----
By convention, this block sets the following Digital Metadata fields:
uuid_str : string
Value provided by the `uuid_str` argument.
sample_rate_numerator : int
Value provided by the `sample_rate_numerator` argument.
sample_rate_denominator : int
Value provided by the `sample_rate_denominator` argument.
center_frequencies : list of floats with length `num_subchannels`
Subchannel center frequencies as specified by
`center_frequencies` argument and 'rx_freq' stream tags.
Additional metadata fields can be set using the `metadata` argument and
stream tags. Nested dictionaries are permitted and are helpful for
grouping properties. For example, receiver-specific metadata is
typically specified with a sub-dictionary using the 'receiver' field.
This block acts on the following stream tags when `ignore_tags` is
False:
rx_time : (int secs, float frac) tuple
Used to set the sample index from the given time since epoch.
rx_freq : float
Used to set the 'center_frequencies' value in the channel's
Digital Metadata as described above.
metadata : dict
Used to populate additional (key, value) pairs in the channel's
Digital Metadata. Any keys passed in 'metadata' tags should be
included in the `metadata` argument at initialization to ensure
that they always exist in the Digital Metadata.
"""
dtype = np.dtype(dtype)
# create structured dtype for interleaved samples if necessary
if is_complex and (not np.issubdtype(dtype, np.complexfloating)
and not dtype.names):
realdtype = dtype
dtype = np.dtype([("r", realdtype), ("i", realdtype)])
if num_subchannels == 1:
in_sig = [dtype]
else:
in_sig = [(dtype, num_subchannels)]
gr.sync_block.__init__(self,
name="digital_rf_channel_sink",
in_sig=in_sig,
out_sig=None)
self._channel_dir = channel_dir
self._channel_name = os.path.basename(channel_dir)
self._dtype = dtype
self._subdir_cadence_secs = subdir_cadence_secs
self._file_cadence_millisecs = file_cadence_millisecs
self._sample_rate_numerator = sample_rate_numerator
self._sample_rate_denominator = sample_rate_denominator
self._uuid_str = uuid_str
self._ignore_tags = ignore_tags
self._is_complex = is_complex
self._num_subchannels = num_subchannels
self._is_continuous = is_continuous
self._compression_level = compression_level
self._checksum = checksum
self._marching_periods = marching_periods
self._stop_on_skipped = stop_on_skipped
self._stop_on_time_tag = stop_on_time_tag
self._debug = debug
self._work_done = False
self._samples_per_second = np.longdouble(
np.uint64(sample_rate_numerator)) / np.longdouble(
np.uint64(sample_rate_denominator))
if min_chunksize is None:
self._min_chunksize = max(int(self._samples_per_second // 1000), 1)
else:
self._min_chunksize = min_chunksize
# reduce CPU usage by setting a minimum number of samples to handle
# at once
# (really want to set_min_noutput_items, but no way to do that from
# Python)
try:
self.set_output_multiple(self._min_chunksize)
except RuntimeError:
traceback.print_exc()
errstr = "Failed to set sink block min_chunksize to {min_chunksize}."
if min_chunksize is None:
errstr += (
" This value was calculated automatically based on the sample rate."
" You may have to specify min_chunksize manually.")
raise ValueError(errstr.format(min_chunksize=self._min_chunksize))
# will be None if start is None or ''
self._start_sample = util.parse_identifier_to_sample(
start, self._samples_per_second, None)
if self._start_sample is None:
if self._ignore_tags:
raise ValueError("Must specify start if ignore_tags is True.")
# data without a time tag will be written starting at global index
# of 0, i.e. the Unix epoch
# we don't want to guess the start time because the user would
# know better and it could obscure bugs by setting approximately
# the correct time (samples in 1970 are immediately obvious)
self._start_sample = 0
self._next_rel_sample = 0
# stream tags to read (in addition to rx_time, handled specially)
if LooseVersion(gr.version()) >= LooseVersion("3.7.12"):
self._stream_tag_translators = {
# disable rx_freq until we figure out what to do with polyphase
# pmt.intern('rx_freq'): translate_rx_freq,
pmt.intern("metadata"):
translate_metadata
}
else:
# USRP source in gnuradio < 3.7.12 has bad rx_freq tags, so avoid
# trouble by ignoring rx_freq tags for those gnuradio versions
self._stream_tag_translators = {
pmt.intern("metadata"): translate_metadata
}
# create metadata dictionary that will be updated and written whenever
# new metadata is received in stream tags
if metadata is None:
metadata = {}
self._metadata = metadata.copy()
if center_frequencies is None:
center_frequencies = np.array([0.0] * self._num_subchannels)
else:
center_frequencies = np.ascontiguousarray(center_frequencies)
self._metadata.update(
# standard metadata by convention
uuid_str="",
sample_rate_numerator=self._sample_rate_numerator,
sample_rate_denominator=self._sample_rate_denominator,
center_frequencies=center_frequencies,
)
# create directories for RF data channel and metadata
self._metadata_dir = os.path.join(self._channel_dir, "metadata")
if not os.path.exists(self._metadata_dir):
os.makedirs(self._metadata_dir)
# sets self._Writer, self._DMDWriter, and adds to self._metadata
self._create_writer()
# dict of metadata samples to be written, add for first sample
# keys: absolute sample index for metadata
# values: metadata dictionary to update self._metadata and then write
self._md_queue = defaultdict(dict)
self._md_queue[self._start_sample] = {}