GRC, Recording chunks of spectrum triggered on input signal level

Hello,

Being limited in my programming skills, I would very much like to do the
following in Gnuradio Companion:

  • Sample an input stream (from RTL-SDR)
  • Generate a trigger signal based on the input stream
  • If a trigger criterion is met, save/sink the data stream for a preset
    time and give the file a name based on time of acquisition (or similar)
  • Reset the flow and start all over.

Getting the input stream is no problem and I believe I know how to
generate the trigger signal, but starting a sink (with a new filename)
for a preset time (number of samples is fine) based on this signal seems
tricker (not to mention the file naming part).

If anyone can provide suggestions for how to

  • start a new sink (new file) based on an integer signal shifting from 0
    to 1
  • automatically name each file sequence, sequential numbering is OK

this would be very much appreciated!

Many thanks in advance!

Regards,
Staffan

Hi Staffan,

I think that you’ll find the things you describe can be best noted more
or less algorithmically (which you have already done!); and thus, I’d
think it’s easier to actually write that specific sink you need than to
do what you want to do in GRC (I must admit I can’t think of a way of
doing that in GRC… it’s just so un-graphically-clickable :wink: ).

Now, this might sound like bad news to you, but I assure you that
writing a python block is not as hard as it might sound to you; just
follow the first few of our new guided tutorials [1] and you might write
your own sink that writes each chunk of samples – as your detector
tagged it – to a new file.

Greetings, and happy hacking,
Marcus

[1]http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorials

See my note about dynamic recording of file names:

The file sink is either being directed to “filename” or “/dev/null”.
You
can dynamically change that during the flow with a boolean check box.
In
your case, instead of the check box, you would setup a probe to monitor
your
integer, and maybe probe at 10 times a second, which would change the
file
name.

The actual “filename” is a python statement that concatenates the system
time and other info into a formatted string.

I’ll post an example GRC file tonight that shows the dynamic recording
with
time stamped file. I’m going to try the ARRL Frequency Measurement test
tonight, and wrote a GRC flow with that functionality (not the probe
part,
but I’m using probes to display the channel power).

Lou
KD4HSO

Staffan Bruce wrote

this would be very much appreciated!

Many thanks in advance!

Regards,
Staffan


Discuss-gnuradio mailing list

Discuss-gnuradio@

Discuss-gnuradio Info Page


View this message in context:
http://gnuradio.4.n7.nabble.com/GRC-Recording-chunks-of-spectrum-triggered-on-input-signal-level-tp51302p51305.html
Sent from the GnuRadio mailing list archive at Nabble.com.

Here is the file:

https://dl.dropboxusercontent.com/u/49570443/fmt.grc

Lou

madengr wrote

I’ll post an example GRC file tonight that shows the dynamic recording
with time stamped file. I’m going to try the ARRL Frequency Measurement
test tonight, and wrote a GRC flow with that functionality (not the probe
part, but I’m using probes to display the channel power).


View this message in context:
http://gnuradio.4.n7.nabble.com/GRC-Recording-chunks-of-spectrum-triggered-on-input-signal-level-tp51302p51309.html
Sent from the GnuRadio mailing list archive at Nabble.com.

Hello all,

Many, many, thanks for the suggestions! I just tried the example by Lou

very good way to update the filename - didn’t realize the variable
statement
was that powerful.
I will also test the tagged file sink and - indeed - I have started
reading
the HOWTOs.

Again, many thanks for the very fast response from you all!

Regards,
Staffan


View this message in context:
http://gnuradio.4.n7.nabble.com/GRC-Recording-chunks-of-spectrum-triggered-on-input-signal-level-tp51302p51317.html
Sent from the GnuRadio mailing list archive at Nabble.com.

You can refer “uhd_burst_detector.py” in “gnuradio/examples/tags” as a
starting point.

Regards
Sreeraj Rajendran

On 11/12/2014 02:54 PM, Staffan Bruce wrote:

Hello,
Being limited in my programming skills, I would very much like to do the
following in Gnuradio Companion:

  • Sample an input stream (from RTL-SDR)
  • Generate a trigger signal based on the input stream
  • If a trigger criterion is met, save/sink the data stream for a preset
    time and give the file a name based on time of acquisition (or similar)
  • Reset the flow and start all over.

The Tagged File Sink does most of what you’re looking for.
src -> trigger -> tagged file sink -> “timestamped” files

Hello,

After some weekend experimenting I believe I have most (most…) of it
working. Sinking to a USB stick is not working so well by the way…
One thing that is still a challenge is how to set the filename. You
provided
a very good way of timestamping, but when I try this, it only evaluates
once - when I start the script. Is there any way to force re-evaluation
of a
variable?
In addition, it would be great to have some kind of a counter (variable,
x =
x + 1) that can be updated depending on a state change - for example
when a
trigger event occurrs. I tried some different versions, but mainly ended
up
in circular references…

Any suggestions would be highly appreciated!

Regards,
Staffan

If you are using an “if” statement to switch between filename and
/dev/null,
try putting the filename construction in the “if” statement, instead of
a
separate variable. That may make it evaluate every time the “if”
statement
is called.

My example used the LO frequency as part of the filename, and every time
the
QT GUI slider changed the LO, it probably updated the filename.

If that does not work, maybe you can use a probe to examine a signal,
say
10x a second. Then the probe level() function could be used as part of
the
filename. That would at least change it 10x a second.

For the counter, maybe you could also use a probes to look at a signal
before and after a N sample delay, where delay and sample rate is about
the
same time as your probe rate; then this pseudocode:

if now.level() != delayed.level() then count = count +1

At this point though you ought to delve into the Python. As long as you
are
not using the QT GUI, the code is pretty straight forward. You can use
probes to pull values out of the flow and evaluate them in Python.

Thanks,
Lou
KD4HSO

Staffan wrote

In addition, it would be great to have some kind of a counter (variable, x
Staffan

View this message in context:
http://gnuradio.4.n7.nabble.com/GRC-Recording-chunks-of-spectrum-triggered-on-input-signal-level-tp51302p51339.html
Sent from the GnuRadio mailing list archive at Nabble.com.

All these workarounds seems hacky
Is there a paradigm that can handle this.

It works, many thanks!

It seems like the changing of a variable in itself does not trigger an
update of other variables (that are depending on the first one), but
using a
button or probe will trigger an update of the variables that are
depending
on them. Could this be something to consider for GnuRadio/Companion,
i.e.,
dependencies between variables and assuring that they are updated when a
change is occurring in one of them?

Still, file sink notices the change of the variable it is depending on
and
that is enough. Now I have a good way of making separate recordings -
great!

…and yes - time to start learning how to code.

Regards,
Staffan

On 11/18/2014 04:17 PM, Staffan Bruce wrote:

It works, many thanks!

It seems like the changing of a variable in itself does not trigger an
update of other variables (that are depending on the first one), but
using a button or probe will trigger an update of the variables that
are depending on them. Could this be something to consider for
GnuRadio/Companion, i.e., dependencies between variables and assuring
that they are updated when a change is occurring in one of them?
The dependency tree in GRC does work, but not “backwards”. If b
depends on a, and a changes, b will be updated, but not the other way
around.

Still, file sink notices the change of the variable it is depending on
and that is enough. Now I have a good way of making separate
recordings - great!

…and yes - time to start learning how to code.
I will point out, gently, that this is software defined radio, rather
than, for example, interpretive-dance defined radio. So going into it
expecting
to never have to actually “code” anything is a rather naive. The GRC
“Lego™-like” model can, realistically, only take you so far. For
one, it has
a data-flow model, so doing “algorithmic” things requires that you
escape from that model, which lands you smack in the middle of
fairly-conventional
software development…

If you are using an “if” statement to switch between filename and
If that does not work, maybe you can use a probe to examine a signal, say

re-evaluation of
in circular references…

Discuss-gnuradio mailing list
[email protected]
Discuss-gnuradio Info Page


Marcus L.
Principal Investigator
Shirleys Bay Radio Astronomy Consortium