Tutorial 5: Programming Topics

> 参考：http://gnuradio.org/doc/doxygen/page_msg_passing.html，参考的这是API文档，翻译已经完成，戳[这里](http://blog.leanote.com/post/2997215859/75c085268e61)可以看。

# Programming Topics

Tags, Messages and PMTs

目标：

* 学习PMTs
* 理解tags是什么/有什么用/如何用
* 理解stream和message passing的区别
* 更多高级block方面的知识

前提：

* 熟悉C++和Python
* 前面四个教程
    * [Tutorials Introductions](http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorial_Introduction)
    * [GRC Tutorial](http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorial_GRC)
    * [Programming GR in Python](http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorial_GNU_Radio_in_Python)
    * [Programming GR in C++](http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorial_GNU_Radio_in_C++)
    
---------

目前我们已经讨论过一个block到另外一个block的数据流。这些数据往往是采样点，一个数据流的结构会更有意义。例如，一个声卡会源源不断的产生声信号。

在某些情况下，我们不想管道采样流，而是将单个消息传递到另一个块，例如“这是突发的第一个采样”，或者“将发送频率改变为144MHz” 。或者考虑在PHY顶部的MAC层：在较高的通信级别，数据通常在PDU（协议数据单元）而不是流中传递。

在GNU Radio中，我们有两种机制来传递这些消息：

* 与数据流同步，则用[stream tags](http://gnuradio.org/doc/doxygen/page_stream_tags.html)
* 与数据流移步，则用[message passing interface](http://gnuradio.org/doc/doxygen/page_msg_passing.html)

要传递的消息可能是字符串、数组向量、字典表或其他类型的信息，为使消息能够在不同的模块间传递，需要将不同类型的信息抽象为某⼀一特定的数据类型。Python是弱类型语言，在创建变量时无需声明类型。而C++是强类型语言，在创建变量前必须已知它的类型。GNURadio的软件架构决定我们需要在Python和C++中使⽤用同⼀一数据对象，为了解决消息信息类型不同的矛 盾，我们引⼊入了polymorphic types（PMTs），使承载不同信息类型的消息变量转化为统⼀的 PMT类型。!

# 多形态类型（PMT）

## 5.1.1 介绍

多态类型用作从一个块/线程到另一个块的数据的载体，例如流标签(stream tags)和消息传递接口(message passing interfaces)。PMT数据类型可以表示从布尔到字典的各种数据类型。让我们直接看Python代码来了解如何使用PMT：

```
>>> import pmt
>>> P = pmt.from_long(23)
>>> type(P)
<class 'pmt.pmt_swig.swig_int_ptr'>
>>> print P
23
>>> P2 = pmt.from_complex(1j)
>>> type(P2)
<class 'pmt.pmt_swig.swig_int_ptr'>
>>> print P2
0+1i
>>> pmt.is_complex(P2)
True
```

首先，导入pmt模块。然后我们使用from_long()和from_complex()分配两个值(P和P2)。我们可以看到，他们都是相同的类型！这意味着我们可以通过SWIG将这些变量传递给C++，C++可以相应地处理这个类型。

在C++中，与上面相同的代码看起来像这样：

```
#include <pmt/pmt.h>
// [...]
pmt::pmt_t P = pmt::from_long(23);
std::cout << P << std::endl;
pmt::pmt_t P2 = pmt::from_complex(gr_complex(0, 1)); // Alternatively: pmt::from_complex(0, 1)
std::cout << P2 << std::endl;
std::cout << pmt::is_complex(P2) << std::endl;
```

在Python和C++中有两个突出的特点：首先，我们可以简单地打印PMT的内容。这怎么可能？嗯，PMT有内置的能力把它们的值转换为字符串(但不可能所有类型都如此)。第二，PMT必须明显知道它们的类型，因此我们可以查询，例如。通过调用is_complex()方法。

当向PMT类型变量分配非PMT值时，可以使用from_ *方法，并使用to_ *方法转换PMT类型到对应类型。

```
pmt::pmt_t P_int = pmt::from_long(42);
int i = pmt::to_long(P_int);
pmt::pmt_t P_double = pmt::from_double(0.2);
double d = pmt::to_double(P_double);
pmt::pmt_t P_double = pmt::mp(0.2);
```

最后一行显示pmt :: mp()速记函数。它可以节省一些打字时间，因为它从给定的类型正确推断出该使用何种from_函数。

字符串类型在PMT中扮演一个特殊的角色（它们被称为符号symbols），我们将在后面看到，并有自己的转换器：

```
pmt::pmt_t P_str = pmt::string_to_symbol("spam");
pmt::pmt_t P_str = pmt::intern("spam"); // Alias for string_to_symbol()
std::string str = pmt::symbol_to_string(P_str);
```

查看[PMT docs](http://gnuradio.org/doc/doxygen/page_pmt.html)和头文件[pmt.h](http://gnuradio.org/doc/doxygen/pmt_8h.html)查看转化函数。在Python中，我们可以使用弱类型，并且实际上有一个帮助函数来完成这些转换（C++的帮助函数pmt :: mp（）只适用于PMT，而且功能不强）：
```
P_int = pmt.to_pmt(42)
i = pmt.to_python(P_int)
P_double = pmt.to_pmt(0.2)
d = pmt.to_double(P_double)
```

另一方面，有三个有用的PMT常量，可以在Python和C ++域中使用。在C ++中，这些可以这样使用：
```
pmt::pmt_t P_true = pmt::PMT_T;
pmt::pmt_t P_false = pmt::PMT_F;
pmt::pmt_t P_nil = pmt::PMT_NIL;
```

在Python中：
```
P_true = pmt.PMT_T
P_false = pmt.PMT_F
P_nil = pmt.PMT_NIL
```

pmt.PMT_T和pmt.PMT_F分别是表示True和False的布尔PMT类型。 PMT_NIL类似于NULL或None，可用于缺省参数或返回值，通常表示发生了错误。

为了能够回到C++数据类型，我们需要能够从PMT中找出类型。 is_ *方法帮助我们这样做：
```
double d;
if (pmt::is_integer(P)) {
    d = (double) pmt::to_long(P);
}
else if (pmt::is_real(P)) {
    d = pmt::to_double(P);
}
else {
    // We really expected an integer or a double here, so we don't know what to do
    throw std::runtime_error("expected an integer!");
}
```

我们可以通过使用pmt::equal()函数比较PMT而不知道它们的类型：
```
if (pmt::eq(P_int, P_double)) {
    std::cout << "Equal!" << std::endl; // This line will never be reached
}
```

有更多的类似eq的函数，用于比较不同的东西：[pmt :: eq()](http://gnuradio.org/doc/doxygen/namespacepmt.html#a5c28635e14287cc0e2f762841c11032f)和[pmt :: eqv](http://gnuradio.org/doc/doxygen/namespacepmt.html#a25467c81e1c5f4619a9cabad7a88eed5)。

## 5.1.2 更多复杂类型

PMT可以容纳各种类型。使用Python方法pmt.to_pmt（），我们可以让大多数Pythons标准类型的开箱即用：

```
P_tuple = pmt.to_pmt((1, 2, 3, 'spam', 'eggs'))
P_dict = pmt.to_pmt({'spam': 42, 'eggs': 23})
```

但是在C++域中这些意味着什么？嗯，c++里有有定义[tuples](http://gnuradio.org/doc/doxygen/namespacepmt.html#a32895cc5a614a46b66b869c4a7bd283c)和[字典](http://gnuradio.org/doc/doxygen/namespacepmt.html#aba10563e3ab43b8d52f9cb13132047cf)的PMT类型，键和值均是PMTs。

因此，像Python示例一样创建tuple的话，C++代码将如下所示：
```
pmt::pmt_t P_tuple = pmt::make_tuple(pmt::from_long(1), pmt::from_long(2), pmt::from_long(3), pmt::string_to_symbol("spam"), pmt::string_to_symbol("eggs"))
```

字典的处理有些复杂：
```
pmt::pmt_t P_dict = pmt::make_dict();
P_dict = pmt::dict_add(P_dict, pmt::string_to_symbol("spam"), pmt::from_long(42));
P_dict = pmt::dict_add(P_dict, pmt::string_to_symbol("eggs"), pmt::from_long(23));
```

如您所见，我们首先需要创建一个字典，然后单独分配每个键/值对。

tuple的变体是向量。像Python的tuple和list一样，PMT向量是可变的，而PMT的tuple不是。事实上，PMT向量是唯一可变的PMT数据类型。当更改值或将项目添加到字典时，我们实际上正在创建一个新的PMT。

要创建一个向量，我们可以将其初始化为一定长度，并用一个初始值填充所有元素。然后我们可以更改项目或引用它们：

```
pmt::pmt_t P_vector = pmt::make_vector(5, pmt::from_long(23)); // Creates a vector with 5 23's as PMTs
pmt::vector_set(P_vector, 0, pmt::from_long(42)); // Change the first element to a 42
std::cout << pmt::vector_ref(P_vector, 0); // Will print 42
```

在Python中，我们可以做所有这些步骤（使用pmt.make_vector（）等），或转换列表：
```
P_vector = pmt.to_pmt([42, 23, 23, 23, 23])
```

向量也不同于tuple，在某种意义上，我们可以直接将数据类型加载到元素中，元素不必是PMT。

假如我们要通过传递8个浮点值到另一个块（比如，这些可能是一个滤波器的特性）。每一个元素和PMT之间的转化是非常麻烦的，因为向量的所有元素都相同的类型。

在这种情况下，我们可以使用特殊的向量类型：
```
pmt::pmt_t P_f32vector = pmt::make_f32vector(8, 5.0); // Creates a vector with 8 5.0s's as floats
pmt::f32vector_set(P_f32vector, 0, 2.0); // Change the first element to a 2.0
float f = f32vector_ref(P_f32vector, 0);
std::cout << f << std::endl; // Prints 2.0
size_t len;
float *fp = pmt::f32vector_elements(P_f32vector, len);
for (size_t i = 0; i < len; i++)
    std::cout << fp[i] << std::endl; // Prints all elements from P_f32vector, one after another
```

Python有一个类似的概念：[Numpy数组](http://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html)。像往常一样，PMT库理解这一点并按预期转换：
```
P_f32vector = pmt.to_pmt(numpy.array([2.0, 5.0, 5.0, 5.0, 5.0], dtype=numpy.float32))
print pmt.is_f32vector(P_f32vector) # Prints 'True'
```

这里，'f32'表示'float，32位'。PMT知道大多数典型的固定宽度数据类型，例如'u8'（无符号8位字符）或'c32'（I和Q均为32位浮点的复数）。请查阅[手册](http://gnuradio.org/doc/doxygen/namespacepmt.html)以获取完整的类型列表。

谨慎的使用这一点 - 它允许我们传递任何可以在内存中表示的东西。

## 5.1.3 Pairs, cons-es and cars

[pairs和cons](http://en.wikipedia.org/wiki/Cons)是一个源于Lisp的概念。最简单的解释是：如果你结合两个PMT，它们形成一个新的PMT，它是这两个PMT的pair（或者说cons）（不要担心奇怪的名字，很多源自Lisp的东西都很奇怪，想想单词“construct”）。

与向量或tuple类似，pairs是将消息的若干分量封装到单个PMT中的有用方式。使用上一节中生成的PMT，我们可以将其中两个组合成一个pair，这里是Python：
```
P_pair = pmt.cons(pmt.string_to_symbol("taps"), P_f32vector)
print pmt.is_pair(P_pair) # Prints 'true'
```

你可以结合tuple，字典，向量或pair。这个结构是非常成熟的，因此在GNU Radio中经常使用。

那么我们如何解构一对呢？这就是car和cdr功能。让我们用C++解构刚刚那个pair：
```
pmt::pmt_t P_key = pmt::car(P_pair);
pmt::pmt_t P_f32vector2 = pmt::cdr(P_pair);
std::cout << P_key << std::endl; // Will print 'taps' using the PMT automatic conversion to strings
```

对于更高级的pair操作，请参阅[文档](http://gnuradio.org/doc/doxygen/namespacepmt.html#a7ab95721db5cbda1852f13a92eee5362)和[维基百科页面的car和cdr](https://en.wikipedia.org/wiki/Car_and_cdr)。

# 5.2 Stream Tags

当两个块之间有数据流（例如，样本从一个块流向另一个块）时，我们可以使用(stream tag)[http://gnuradio.org/doc/doxygen/page_stream_tags.html]（以下称流标记）。流标记是连接到特定item（以下称粒度）的消息。这样，我们可以在数据流中同步发送message。

流标签在数据流中具有固定位置，此外，流标签还具有三个属性：

* 一个key，用来标识某个tag
* 一个value，可以是任何PMT类型
* 一个source ID(可选)，有助于标识此特定标记的来源。

block是否使用这些信息取决于具体情况。一般，大部分block会自动传播tags，意思就是流标签附加到输出的同一粒度（或相应的粒度）。使用流标签的block通常用key来得到流标签，然后处理它们。

比如：

![title](https://leanote.com/api/file/getImage?fileId=586de0ebab6441236e003954)

在此流程图中，我们有两个来源：正弦波信源和一个tag strobe。tag strobe每输出1000个粒度（粒度的实际值始终为零），就会附加一个标签。加法器之后的信号与我们产生的正弦波相同，因为tag strobe输出的粒度实际值都是零。但是，tags保持附着在数据流中相同的位置！这意味着每1000个粒度的正弦曲线都会有一个流标签。QT scope可以显示标签，甚至触发它们。

![title](https://leanote.com/api/file/getImage?fileId=586de22dab6441209e003a18)

现在，我们有了一种机制，可以任意地将任何元数据附加到特定粒度上。GNU Radio中有好几个块使用流标签。其中一个就是UHD Sink块，其用于与USRP设备进行传输。它有着具有特定键的标签，其中之一是tx_freq，可用于设置流式传输时USRP的发送频率。

## 5.2.1 给QPSK解调器添加tags

回到我们的QPSK解调示例，我们可能想要添加一个功能，告诉下游的block解调的不是很好。这里block必须输出一些东西。因此，我们可以使用流标签来通知输入并不是很好，输出是不可靠的。

假设一个失败的情况，比如，当输入幅度太小，小于0.01的时候。当幅度低于此值时，我们可以输出一个标签。另一个标签仅在振幅恢复后发送。我们扩展工作函数如下：

```
if (std::abs(in[i]) < 0.01 and not d_low_ampl_state) {
    add_item_tag(0, // Port number
                 nitems_written(0) + i, // Offset
                 pmt::mp("amplitude_warning"), // Key
                 pmt::from_double(std::abs(in[i])) // Value
    );
    d_low_ampl_state = true;
}
else if (std::abs(in[i]) >= 0.01 and d_low_ampl_state) {
    add_item_tag(0, // Port number
        nitems_written(0) + i, // Offset
        pmt::mp("amplitude_recovered"), // Key
        pmt::PMT_T // Value
    );
    d_low_ampl_state = false; // Reset state
}
```

在Python中，代码看起来像这样（假设我们的块类的一个成员叫d_low_ampl_state）：
```
# The vector 'in' is called 'in0' here because 'in' is a Python keyword
if abs(in0[i]) < 0.01 and not d_low_ampl_state:
    self.add_item_tag(0, # Port number
                 self.nitems_written(0) + i, # Offset
                 pmt.intern("amplitude_warning"), # Key
                 pmt.from_double(numpy.double(abs(in0[i]))) # Value
                 # Note: We need to explicitly create a 'double' here,
                 # because in0[i] is an explicit 32-bit float here
    )
    self.d_low_ampl_state = True
elif abs(in0[i]) >= 0.01 and d_low_ampl_state:
    self.add_item_tag(0, # Port number
                 self.nitems_written(0) + i, # Offset
                 pmt.intern("amplitude_recovered"), # Key
                 pmt.PMT_T # Value
    )
    self.d_low_ampl_state = False; // Reset state
```

我们还可以创建一个标签数据类型[tag_t](http://gnuradio.org/doc/doxygen/structgr_1_1tag__t.html)，并直接传递：
```
if (std::abs(in[i]) < 0.01 and not d_low_ampl_state) {
    tag_t tag;
    tag.offset = nitems_written(0) + i;
    tag.key = pmt::mp("amplitude_warning");
    tag.value = pmt::from_double(std::abs(in[i]));
    add_item_tag(0, tag);
    d_low_ampl_state = true;
}
```

这里是使用流标签版本的解调器的流程图。我们输入20个有效的QPSK符号，然后输入10个零。由于这个块的输出总是为0,1,2或3，所以我们通常没有办法看到输入是否不是这些值中的一个。
![title](https://leanote.com/api/file/getImage?fileId=586ded78ab6441236e003e3a)

这里是输出。你可以看到我们有些tags标记了有效的输入，另外一些标记了不可靠的输入。
![title](https://leanote.com/api/file/getImage?fileId=586ded72ab6441209e003e43)

## 5.2.2 Tag offsets and noutput_items

在说明标签之前，了解偏移很重要。标签偏移是绝对值，并且特定于某个端口！通过block的第一个粒度具有偏移量0，并且只有一个具有该偏移量的样本点（该偏移量是一个无符号的64位整数，这足够让流程图运行很长时间，才会跑到最大值）。

然而，大多数块都工作在相对样本索引上（例如，如果你有一个形式为`for(int i = 0; i <noutput_items; i++)`的循环，i将是一个相对样本索引，因为你不一定需要绝对样本位置）。如果你想知道在开始此循环之前已消耗或生成了多少样本，您可以使用[nitems_read(port_num)](http://gnuradio.org/doc/doxygen/classgr_1_1block.html#a2279d1eb421203bc5b0f100a6d5dc263)和[nitems_written(port_num)](http://gnuradio.org/doc/doxygen/classgr_1_1block.html#a742128a481fcb9e43a3e0cd535a57f9e)方法轻松将相对样本索引转换为绝对样本（请特别注：调用[consume()](http://gnuradio.org/doc/doxygen/classgr_1_1block.html#a47193333ce3fe1536fb1663bf314f63d)和[produce()](http://gnuradio.org/doc/doxygen/classgr_1_1block.html#aa5581727d057bdd8113f8b2a3fc5bd66)函数会改变这些值）。

在以下示例中，我们将以交替方式流式传输有效的QPSK符号和零。流标记会如何被添加到粒度上：

下游的block现在可以使用这些流标签。为此，我们需要调用get_tags_in_range()，该函数读取给定绝对偏移范围内的标签。比如，要从前100个输入粒度中的读取标签，可以这么写：
```
std::vector<tag_t> tags;
get_tags_in_range(
    tags, // Tags will be saved here
    0, // Port 0
    nitems_read(0), // Start of range
    nitems_read(0) + 100, // End of range
    pmt::mp("my_tag_key") // Optional: Only find tags with key "my_tag_key" 
);
```

标签将全部保存到向量标签中。虽然流标签会被放入此向量中，但并不会按任何特定顺序排列。可选的第五个参数允许我们使用特定键过滤标记，这样我们可以查找某一种类型的标记。

## Tag propagation

我们现在知道如何向数据流添加标签，以及如何读取它们。但是读取流标签之后呢？没有使用的标签会发生什么？毕竟，有许多block根本不关心标签。

答案是：它取决于block的标签传播策略，这决定了block会对进入它的流标签做出的行为。

有[三种策略](http://gnuradio.org/doc/doxygen/classgr_1_1block.html#abc40fd4d514724a5446a2b34b2352b4e)可供选择：

* TPP_ALL_TO_ALL:在任何端口上进入的任何标记都会自动传播到所有输出端口（这是默认设置）
* TPP_ONE_TO_ONE:在端口N上进入的标记传播到输出端口N.这仅适用于具有相同数目的输入和输出端口的块。
* TPP_DONT:进入块的标签不会自动传播。只有在此块中创建的标签（使用add_item_tag（））才会出现在输出流上。

我们通常使用[@set_tag_propagation_policy](http://gnuradio.org/doc/doxygen/classgr_1_1block.html#a476e218927e426ac88c26431cbf086cd)在块的构造函数中设置标签传播策略

当标记传播策略设置为TPP_ALL_TO_ALL或TPP_ONE_TO_ONE时，GNU Radio调度器会确定哪个输出项对应于哪个输入项。block可以读取它们，也可以创建新的流标签，已经存在的流标签会以适当的方式跟随数据流移动。

作为示例，考虑内插块。请参见以下流程图：

![title](https://leanote.com/api/file/getImage?fileId=586df9b8ab6441209e0043c0)

输出结果如下：
![title](https://leanote.com/api/file/getImage?fileId=586dfa5bab6441209e004410)

每隔10个样本打上标签，然后数据流通过一个块，每个样本重复100次。根据传播策略，标签不会重复（或者说，并没有操作标签），因此调度程序会小心地将每个标签放在与之前输入项对应的输出项上。这里，调度器做出有根据的猜测，并将标签放在100个项目的第一个。

注意：我们不能在这里使用一个QT GUI Time，因为这两个速率是不一样的，可以观察一下x轴的不同。

抽取块是类似的，考虑这个非常简单的流程图，以及样本的位置：
![title](https://leanote.com/api/file/getImage?fileId=586dfb46ab6441209e004443)

输出结果如下:
![title](https://leanote.com/api/file/getImage?fileId=586dfb40ab6441209e004442)

我们可以看到，没有标签被破坏，标签确实以100个粒度的十分之一来间隔。当然，通过该block传输的实际粒度可能被销毁或修改（比如抽取FIR滤波器）。

事实上，这适用于任何改变速率的block。注意，如果输入和输出的标签位置的关系不是很明确，GNU Radio调度器将尽可能地尝试和接近。

这是另一个有趣的例子：有一个延迟块，以及标签的位置：
![title](https://leanote.com/api/file/getImage?fileId=586dfbe4ab6441209e004470)

结果如下：
![title](https://leanote.com/api/file/getImage?fileId=586dfc0dab6441236e004385)

在延迟块之前，变量定位在斜坡的开始处。延迟后，他们仍然在相同的位置！我们可以检查延迟 块的源代码，我们会发现并没有处理标签的代码。取而代之的是，延迟块向调度器(声明延迟)[http://gnuradio.org/doc/doxygen/classgr_1_1block.html#acad5d6e62ea885cb77d19f72451581c2]，这才让传播的数据流具有延迟的标记。

使用这些机制，我们可以应付GNU Radio中处理绝大部分标签传播的情况。对于特殊情况，可以block设置标签传播策略为TPP_DONT，然后手动传播标签（实际上，有另一种方式：假设我们想要大多数标签正常传播，但其中几个应该被不同地对待，我们可以使用remove_item_tag（）从输入中删除这些标签;这样，即使标签传播策略并没有设置为TPP_DONT，它们也不会被传播，但这是更高级的使用，在此不再赘述）。

用例：FIR滤波器
------------
（注意：本节要求数字信号处理的知识，如果你不明白一些表达式，可以跳到下一节）

假设我们有一个块，实际上是一个FIR滤波器。我们想让GNU Radio处理标签传播。我们如何配置块？

现在，FIR滤波器具有一个输入和一个输出。所以，如果我们将传播策略设置为TPP_ALL_TO_ALL或TPP_ONE_TO_ONE效果相同，我们可以将其保留为默认值。项目进入和出来的是不同的，所以我们如何匹配输入和输出？由于我们想要保留标签位置的时间，我们需要使用滤波器的群延迟作为标签的延迟（对于该对称FIR滤波器是（N-1）/ 2，其中N是滤波器抽头的数量）。最后，我们可能会内插，抽取或两者（例如，对于采样率更改），我们还需要告诉调度程序这一点。

# 5.3 Message Passing

[消息传递接口](http://gnuradio.org/doc/doxygen/page_msg_passing.html)（Message passing interface）与流标签完全不同。Messages是PMT，它们没有偏移（这不会有任何意义，因为它们并不需要连接到一个粒度上，所以不需要偏移），也没有键（虽然我们可以通过使PMT创建键/值对的pair或字典）。另一个区别是，messages有一个不同的端口，这个端口不能和常规的流式端口相连接。我们称这些新类型的端口为消息端口（message ports），称更早之前介绍的那种端口为流端口（stream port）。

message通常不用于采样，而是用于分组，分组的数据可以以数据包的形式移动。当然，在许多情况下，可以同时使用消息传递和流式接口。

下面是使用流和消息的流程图的简单示例：
![title](https://leanote.com/api/file/getImage?fileId=586e008dab6441236e0044ac)

有几个有趣的事情要指出。首先，存在两个信源，均以规则的间隔输出粒度，每1000毫秒个、每750毫秒一个。虚线连接消息端口，实线表示连接的流端口。事实上，在流程图的上半部分，我们可以看到，在消息传递和流式端口之间可以切换，但是只有当PMT的类型与流式端口的类型匹配时（在这个例子中，流端口的粉红色表示字节类型，这表示发送的PMT数据应该是u8vector的八位数据。

另一个有趣的事实是，我们可以连接多个消息输出端口到单个消息输入端口，这是流端口无法做到的。这是由于messages的异步特性：只要接受块有机会，它可以不必按任何特定顺序处理所有message。从多个block接收messages意味着可能有更多messages要处理。

messages传递到block后会发生什么？这取决于block是如何实现的，这有两种可能性：

* 调用一个消息处理程序，立即处理消息。
* 该消息被写入FIFO缓冲器，并且该块可以在任何必要的时候使用，这通常在work函数中进行。

对于既有消息端口、又有流端口的block，这两个选项中都可以，这取决于blocks。但是，我们强烈建议不要在函数内部处理消息，而是建议使用消息处理程序。由于需要等待messages到达，在work函数中使用messages会阻塞work函数。如果block的messages需要处理，则可以使用消息处理器来接收messages，然后可以在调用work function时用于通知block采取行为。只有在特别明确的场合，我们才能在block中使用方法2。

通过消息传递接口，我们可以编写没有流端口的块，这样work函数就没有什么卵用，因为它是一个专用于数据流的函数。实际上，没有流端口的块通常甚至不具有work函数。

## 5.3.1 PDUs

在前面的流程图中，我们有一个称为PDU to Tagged Stream的块。GNU Radio中的PDU（协议数据单元）具有特殊的PMT类型，它是一个字典（在CAR上）和同类型向量的pair。因此，这将产生有效PDU，没有元数据和10个零作为流数据：
```
pdu = pmt.cons(pmt.make_dict(), pmt.make_u8vector(10, 0))
```

然后，字典中的键/值对被解释为流标签的键/值对。

## 5.3.2 Adding Message Passing to the Code

与流端口不同，消息端口未在I/O签名中定义，但使用[message_port_register_ *](http://gnuradio.org/doc/doxygen/classgr_1_1basic__block.html#a362b6de38292cca9c1d56439a6efad04)函数声明。消息端口也有标识符而不是端口号;那些标识符也是PMT。要将消息的输入或输出端口添加到块，构造函数必须用以下行来修改：
```
// Put this into the constructor to create message ports
message_port_register_in(pmt::mp("in_port_name"));
message_port_register_out(pmt::mp("out_port_name"));
```

要为每次我们收到消息时调用的输入消息端口设置一个函数作为消息处理程序，我们添加如下行：
```
// Put this into the constructor after the input port definition:
set_msg_handler(
    pmt::mp("in_port_name"), // This is the port identifier
    boost::bind(&block_class_name::msg_handler_method, this, _1)  // [FIXME class name] Bind the class method
);
```

我们使用[Boost's bind](http://www.boost.org/doc/libs/1_55_0/libs/bind/bind.html)的手法告诉GNU Radio关于在这个输入端口上要调用的消息的函数。如果你不知道boost::bind，不要担心，语法总是相同的：第一个参数是一个指向被调用的方法的指针，第二个是this，以保证从正确的类中调用该方法，第三个参数是_1，这意味着该函数接受一个参数，即消息PMT。

所有消息处理程序，如上面使用的函数“msg_handler_method”，具有相同的函数原型，并且是块的实现类的成员：
```
void msg_handler_method(pmt::pmt_t msg);
```

在Python块中，这些行将如下所示：
```
# Put this into the constructor to create message ports
self.message_port_register_in(pmt.intern("in_port_name"))
self.message_port_register_out(pmt.intern("out_port_name"))
self.set_msg_handler(pmt.intern("in_port_name"), self.msg_handler_method) # No bind necessary, we can pass the function directly
```

消息输入和输出可以类似地连接到流式端口，使用(msg_connect](http://gnuradio.org/doc/doxygen/classgr_1_1hier__block2.html#a8abff96c559930893d3ffdb22a3c43fd)而不是connect：
```
tb = gr.top_block()
# Send the string "message" once every 1000 ms
src = blocks.message_strobe(pmt.to_pmt("message"), 1000)
dbg = blocks.message_debug()
tb.msg_connect(src, "pdus", dbg, "print")
```

注意我们调用了msg_connect（），而不是用于流端口的connect（）函数。

## 5.3.3 例子：Chat Application
让我们构建一个使用消息传递的应用程序。聊天程序是一种理想的用例，因为它等待用户键入消息，然后发送它。

我们将创建两个块：一个用于发送消息，一个用于接收。后者很简单：当它收到一条消息，它会将其打印到控制台。前者有点更花哨：首先它会预先添加一个字符串，我们用来标识发送人的用户名。此外，它将从字符串中剥离任何不可打印的字符（我们将在接收器中做同样的，只是为了确保没有人用有趣的字符拧我们的控制台）。

最后，让我们指定我们将传输数据为u8vectors。这使得我们的块与GNU Radio中的其他块兼容。

让我们看看块：[https://github.com/gnuradio/gr-tutorial/blob/master/python/chat_blocks.py](https://github.com/gnuradio/gr-tutorial/blob/master/python/chat_blocks.py)

第一个块chat_sanitizer有一个函数post_message（），它可以从外部调用以启动消息传输。它执行我们前面提到的字符串过滤，然后将字符串转换为一个u8vector。

第二个块chat_receiver也有一个函数（handle_msg（）），当一个消息发布到这个块时，它总是被调用。这是通过将此函数注册为消息处理程序来启用的。

注意，我们不是简单地传递u8vector，而是传递u8vector和另一个PMT的pair，我们可以将其用作元数据。作为示例，将流转换为PDU的块将输出流数据作为数据，并且将标签作为该PMT对中的元数据输出。

该文件包含两个块，我们可以在流程图中使用，但也可以直接运行。在这种情况下，它将直接连接这两个块，并为用户提供提示，以便我们可以测试这些块。

更详细的示例在[https://github.com/gnuradio/gr-tutorial/blob/master/examples/tutorial5/chat_app.grc](https://github.com/gnuradio/gr-tutorial/blob/master/examples/tutorial5/chat_app.grc)中给出。这里我们可以看到如何使用这两个块来创建实际使用QPSK映射来传输数据的流程图。

5.4 Quiz

* 如果要创建一个包含100个复杂样本的PMT，如何初始化它？
* 假设你已经使用`pmt::to_double（）`创建了一个PMT，但是你想把这个值赋给一个整型数据类型（例如`int pmt_val`）。你是怎样做的？
* 什么是消息处理程序？
* 说你写了一个TCP块，它将数据传递到一个IP块。你会使用消息传递还是流媒体接口？
* 假设您有一个突发检测块，将样本流向下游解调块。您现在还希望将元数据传递到下游块。您会使用流标签还是消息界面？

逆风起笔