Re: Python module: object as a reference (just as "Block ID" in "Function Probe" block)

[Cyrille Morin]

Hi Luke,

I've had this issue before.

The problem is that the Function Probe block is not actually a block, 
it's just a way to write code directly into the top_block python file, 
and do the top_block object is the one calling the block you want, which 
is not an issue since, it knows them, it created them.

Now, whatever block you create doesn't have reference to the other 
blocks, and I could not find a way to give it to them directly, so what 
I found is to give the top_block object to yours, and also the name of 
the block(s) you want, and call them with getattr(top_block_object, 
wanted_block_name).whatever_function() . It needs to be the name used 
for the exact block you want, not the type, you can find it in the id 
field in the parameters, or by reading the top_block file.

The other issue is the fact that, with an embedded block, when you save 
it, GRC creates an instance of the object automatically with the default 
parameters, possibly to find out its signature and be able to display it 
properly. But, at that point, the top block object doesn't exist, so the 
execution will stop and GRC will complain.

If you work with an OOT python block, you won't have this issue, but if 
you really want to stick with embedded, I've done that too:

If the constructor is not the function that gets the top_block as input, 
but another function (not called in the init phase), you can have it be 
called by a function probe (the frequency doesn't need to be high) and 
put "self" as argument. Then you can use it to call whatever in your 
function, or even store it in your block object for later use.

This is really hacky, and there may be a better way to do it but I 
couldn't find at the time, and it works without issue.

Tell me if this was not clear, or if you need example code.

Cyrille

Le 21/02/2020 à 00:24, Lukas Haase a écrit :
> Hi,
>
> I am using the "Embedded Python Block" to create a simple controller that 
> controls my USRP Source/Sink blocks.
> These blocks support a message interface but unfortunately this is pretty 
> useless except for the simplest applications (I need to control advanced tuning 
> with timed commands, GPIO ports etc).
>
> Hence I need to call the methods of these objects directly but I need a 
> reference to them inside my custom block.
> Within my python block I cannot reference the parent blocks, hence I need to 
> pass a reference to these two objects via the constructor (and parameters).
> Basically I want to do the same as parameter "Block ID" from the block "Function 
> Probe" does.
>
> What is the best way to implement this?
>
> Thanks,
> Luke
>
>
>
>
>
>
> PS: Example:
>
> class blk(gr.sync_block):  # other base classes are basic_block, decim_block, 
> interp_block
>      def __init__(self, sample_rate=1.0, usrp_source_block=''):  # only default 
> arguments here
>          """arguments to this function show up as parameters in GRC"""
>          gr.sync_block.__init__(
>              self,
>              name='Controller',   # will show up in GRC
>              in_sig=[np.float32],
>              out_sig=[np.float32]
>          )
>          # if an attribute with the same name as a parameter is found,
>          # a callback is registered (properties work, too).
>          self.sample_rate = sample_rate
>                 self.usrp_source_block = usrp_source_block
>
>                 # here I want to execute for example
>                 self.usrp_source_block.set_gain(5.0)
>
> When I then create an USRP Sink object with ID uhd_usrp_sink_0 and enter as 
> parameter I get the error:
>
> Param - Usrp Source Block(usrp_source_block):
>         Value "uhd_usrp_sink_0" cannot be evaluated:
>         name 'uhd_usrp_sink_0' is not defined