Radiolab ↯

Tecnologia y Telecomunicaciones.

Construcción de Módulos y Bloques en GNU Radio Companion

Los módulos en GNU Radio nos permiten extender la funcionalidad de la plataforma, es decir, podemos construir bloques con nuestro propio código para el procesamiento de datos y así tener mayor poder y flexibilidad.

Para este tutorial asumimos que completamos satistactoriamente la instalación de GNU Radio Companion.

Dentro de nuestra carpeta “grc” ejecutamos el siguiente comando:

1
2

$ git clone https://github.com/mbant/gr-modtool.git
$ cd gr-modtool

Utilizando gr_modtool, crearemos un nuevo módulo llamado “pruebas”:

1
2
3
4

$ gr_modtool newmod
Name of the new module: pruebas
Creating out-of-tree module in ./gr-pruebas... Done.
Use 'gr_modtool add' to add a new block to this currently empty module.

Al revisar el contenido de la carpeta “gr-modtool”, vemos que se ha creado una nueva carpeta llamada “gr-pruebas”, ahora tenemos que hacer una copia el archivo “gr_moodtool.py” dentro de nuestra nueva carpeta.

1
2

$ cp gr_modtool.py gr-pruebas
$ cd gr-pruebas

Contenido en la carpeta del modulo “gr-pruebas”: images

Ahora vamos a crear un nuevo bloque de procesamiento:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

$ gr_modtool add
GNU Radio module name identified: pruebas
Enter code type: general
Language: C++
Enter name of block/code (without module name prefix): demo
Block/code identifier: demo
Enter valid argument list, including default arguments:
Add Python QA code? [Y/n]
Add C++ QA code? [y/N]
Adding file 'demo_impl.h'...
Adding file 'demo_impl.cc'...
Adding file 'demo.h'...
Editing swig/pruebas_swig.i...
Adding file 'qa_demo.py'...
Editing python/CMakeLists.txt...
Adding file 'pruebas_demo.xml'...
Editing grc/CMakeLists.txt...

Para poder utilizar nuestro bloque es necesario editar algunas lineas. Iniciemos:

Editamos nuestro archivo “pruebas_demo.xml” en /gr-pruebas/grc/

(pruebas_demo.xml) download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?xml version="1.0"?>
<block>
  <name>demo</name>
  <key>pruebas_demo</key>
  <category>pruebas</category>
  <import>import pruebas</import>
  <make>pruebas.demo($)</make>

  <param>
    <name>Demo</name>
    <key></key>
    <type>int</type>
  </param>

  <sink>
    <name>in</name>
    <type>int</type>
  </sink>

  <source>
    <name>out</name>
    <type>int</type>
  </source>
</block>

Editamos el archivo “demo_impl.cc” en /gr-pruebas/lib/

Estas son las partes del código que modificaremos:

<+MIN_IN+>, <+MAX_IN+>, <+MIN_OUT+>, <+MAX_OUT+>, <+ITYPE+>, <+OTYPE+>.

(demo_impl.cc) download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

/* -*- c++ -*- */
/* 
 * Copyright 2013 <+YOU OR YOUR COMPANY+>.
 * 
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3, or (at your option)
 * any later version.
 * 
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this software; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street,
 * Boston, MA 02110-1301, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <gnuradio/io_signature.h>
#include "demo_impl.h"

namespace gr {
  namespace pruebas {

    demo::sptr
    demo::make()
    {
      return gnuradio::get_initial_sptr
        (new demo_impl());
    }

    /*
     * The private constructor
     */
    demo_impl::demo_impl()
      : gr::block("demo",
              gr::io_signature::make(0, 0, sizeof(int)),
              gr::io_signature::make(1, 1, sizeof(int)))
    {}

    /*
     * Our virtual destructor.
     */
    demo_impl::~demo_impl()
    {
    }

    void
    demo_impl::forecast (int noutput_items, gr_vector_int &ninput_items_required)
    {
        /* <+forecast+> e.g. ninput_items_required[0] = noutput_items */
    }

    int
    demo_impl::general_work (int noutput_items,
                       gr_vector_int &ninput_items,
                       gr_vector_const_void_star &input_items,
                       gr_vector_void_star &output_items)
    {
        const int *in = (const int *) input_items[0];
        int *out = (int *) output_items[0];

        // Do <+signal processing+>
        // Tell runtime system how many input items we consumed on
        // each input stream.
        consume_each (noutput_items);

        // Tell runtime system how many output items we produced.
        return noutput_items;
    }

  } /* namespace pruebas */
} /* namespace gr */

Para compilar nuestro módulo y bloque creamos un directorio “build” en la carpeta gr-pruebas y dentro de el ejecutamos los siguientes comandos:

1
2
3
4
5

$ mkdir build && cd build
$ cmake ../
$ sudo make
$ sudo make install
$ sudo ldconfig

Para utilizar nuestro bloque, ejecutamos gnuradio-companion y de lado derecho habrá un nuevo módulo llamado “pruebas” y dentro de este nuestro bloque “demo”.

images

Hasta este punto hemos creado un módulo y un bloque de procesamiento, en el siguiente tutorial veremos la creación de un bloque con entradas y salidas funcionales para probarlo en GNU Radio Companion.

Comentarios