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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
/* -*- c++ -*- */
/* Copyright 2015-2016 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
* GNU Radio 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.
*
* GNU Radio 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 GNU Radio; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#ifndef INCLUDED_DIGITAL_HEADER_FORMAT_DEFAULT_H
#define INCLUDED_DIGITAL_HEADER_FORMAT_DEFAULT_H
#include <pmt/pmt.h>
#include <gnuradio/digital/api.h>
#include <gnuradio/digital/header_format_base.h>
#include <gnuradio/digital/header_buffer.h>
#include <gnuradio/logger.h>
#include <boost/enable_shared_from_this.hpp>
namespace gr {
namespace digital {
/*!
* \brief Default header formatter for PDU formatting.
* \ingroup packet_operators_blk
*
* \details
* Used to handle the default packet header.
*
* See the parent class header_format_base for details of how
* these classes operate.
*
* The default header created in this base class consists of an
* access code and the packet length. The length is encoded as a
* 16-bit value repeated twice:
*
* \verbatim
| access code | hdr | payload |
\endverbatim
*
* Where the access code is <= 64 bits and hdr is:
*
* \verbatim
| 0 -- 15 | 16 -- 31 |
| pkt len | pkt len |
\endverbatim
*
* The access code and header are formatted for network byte order.
*
* This header generator does not calculate or append a CRC to the
* packet. Use the CRC32 Async block for that before adding the
* header. The header's length will then measure the payload plus
* the CRC length (4 bytes for a CRC32).
*
* The default header parser produces a PMT dictionary that
* contains the following keys. All formatter blocks MUST produce
* these two values in any dictionary.
*
* \li "payload symbols": the number of symbols in the
* payload. The payload decoder will have to know how this relates
* to the number of bits received. This block knows nothing about
* the payload modulation or the number of bits/symbol. Use the
* gr::digital::header_format_counter for that purpose.
*
* \sa header_format_counter
* \sa header_format_crc
* \sa header_format_ofdm
*/
class DIGITAL_API header_format_default
: public header_format_base
{
public:
header_format_default(const std::string &access_code, int threshold,
int bps);
virtual ~header_format_default();
/*!
* Creates a header from the access code and packet length and
* creates an output header as a PMT vector in the form:
*
* \verbatim
| access code | pkt len | pkt len |
\endverbatim
*
* \param nbytes_in The length (in bytes) of the \p input payload
* \param input An array of unsigned chars of the packet payload
* \param output A pmt::u8vector with the new header prepended
* onto the input data.
* \param info A pmt::dict containing meta data and info about
* the PDU (generally from the metadata portion of the
* input PDU). Data can be extracted from this for the
* header formatting or inserted.
*/
virtual bool format(int nbytes_in,
const unsigned char *input,
pmt::pmt_t &output,
pmt::pmt_t &info);
/*!
* Parses a header of the form:
*
* \verbatim
| access code | pkt len | pkt len | payload |
\endverbatim
*
* This is implemented as a state machine that starts off
* searching for the access code. Once found, the access code is
* used to find the start of the packet and the following
* header. This default header encodes the length of the payload
* a 16 bit integer twice. The state machine finds the header
* and checks that both payload length values are the same. It
* then goes into its final state that reads in the payload
* (based on the payload length) and produces a payload as a PMT
* u8 vector of packed bytes.
*
* \param nbits_in The number of bits in the input array.
* \param input The input as hard decision bits.
* \param info A vector of pmt::dicts to hold any meta data or
* info about the PDU. When parsing the header, the
* formatter can add info from the header into this dict.
* Each packet has a single PMT dictionary of info, so
* the vector length is the number of packets received
* extracted during one call to this parser function.
* \param nbits_processed Number of input bits actually
* processed; If all goes well, this is nbits_in. A
* premature return after a bad header could be less than
* this.
*/
virtual bool parse(int nbits_in,
const unsigned char *input,
std::vector<pmt::pmt_t> &info,
int &nbits_processed);
/*!
* Returns the length of the formatted header in bits.
*/
virtual size_t header_nbits() const;
/*!
* Updates the access code. Must be a string of 1's and 0's and
* <= 64 bits.
*/
bool set_access_code(const std::string &access_code);
/*!
* Returns the formatted access code as a 64-bit register.
*/
unsigned long long access_code() const;
/*!
* Sets the threshold for number of access code bits can be in
* error before detection. Defaults to 0.
*/
void set_threshold(unsigned int thresh=0);
/*!
* Returns threshold value for access code detection.
*/
unsigned int threshold() const;
/*!
* Factory to create an async packet header formatter; returns
* an sptr to the object.
*
* \param access_code An access code that is used to find and
* synchronize the start of a packet. Used in the parser and in
* other blocks like a corr_est block that helps trigger the
* receiver. Can be up to 64-bits long.
* \param threshold How many bits can be wrong in the access
* code and still count as correct.
* \param bps The number of bits/second used in the payload's
* modulator.
*/
static sptr make(const std::string &access_code, int threshold,
int bps = 1);
protected:
uint64_t d_access_code; //!< register to hold the access code
size_t d_access_code_len; //!< length in bits of the access code
uint16_t d_bps; //!< bits/sec of payload modulation
unsigned long long d_data_reg; //!< used to look for access_code
unsigned long long d_mask; /*!< masks access_code bits (top N bits are set where
N is the number of bits in the access code) */
unsigned int d_threshold; //!< how many bits may be wrong in sync vector
int d_pkt_len; //!< Length of the packet to put into the output buffer
int d_pkt_count; //!< Number of bytes bits already received
int d_nbits; //!< num bits processed since reset
//! Access code found, start getting the header
virtual void enter_have_sync();
//! Header found, setup for pulling in the hard decision bits
virtual void enter_have_header(int payload_len);
//! Verify that the header is valid
virtual bool header_ok();
/*! Get info from the header; return payload length and package
* rest of data in d_info dictionary.
*/
virtual int header_payload();
};
} // namespace digital
} // namespace gr
#endif /* INCLUDED_DIGITAL_HEADER_FORMAT_DEFAULT_H */
|
