← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnuradio/trusty

« back to all changes in this revision

Viewing changes to gr-usrp/src/usrp1_source_base.cc

  • Committer: Bazaar Package Importer
  • Author(s): Kamal Mostafa
  • Date: 2010-03-13 07:46:01 UTC
  • mfrom: (2.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100313074601-zjsa893a87bozyh7
Tags: 3.2.2.dfsg-1ubuntu1
https://launchpad.net/bugs/260406
* Fix build for Ubuntu lucid (LP: #260406)
  - add binary package dep for libusrp0, libusrp2-0: adduser
  - debian/rules clean: remove pre-built Qt moc files

Show diffs side-by-side

added added

removed removed

Lines of Context:
gr-usrp/src/usrp1_source_base.cc
1
 
/* -*- c++ -*- */
2
 
/*
3
 
 * Copyright 2004 Free Software Foundation, Inc.
4
 
 * 
5
 
 * This file is part of GNU Radio
6
 
 * 
7
 
 * GNU Radio is free software; you can redistribute it and/or modify
8
 
 * it under the terms of the GNU General Public License as published by
9
 
 * the Free Software Foundation; either version 3, or (at your option)
10
 
 * any later version.
11
 
 * 
12
 
 * GNU Radio is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 * GNU General Public License for more details.
16
 
 * 
17
 
 * You should have received a copy of the GNU General Public License
18
 
 * along with GNU Radio; see the file COPYING.  If not, write to
19
 
 * the Free Software Foundation, Inc., 51 Franklin Street,
20
 
 * Boston, MA 02110-1301, USA.
21
 
 */
22
 
 
23
 
#ifdef HAVE_CONFIG_H
24
 
#include "config.h"
25
 
#endif
26
 
 
27
 
#include <usrp1_source_base.h>
28
 
#include <gr_io_signature.h>
29
 
#include <usrp_standard.h>
30
 
#include <assert.h>
31
 
 
32
 
static const int OUTPUT_MULTIPLE_BYTES = 4 * 1024;
33
 
 
34
 
usrp1_source_base::usrp1_source_base (const std::string &name,
35
 
                                      gr_io_signature_sptr output_signature,
36
 
                                      int which_board,
37
 
                                      unsigned int decim_rate,
38
 
                                      int nchan,
39
 
                                      int mux,
40
 
                                      int mode,
41
 
                                      int fusb_block_size,
42
 
                                      int fusb_nblocks,
43
 
                                      const std::string fpga_filename,
44
 
                                      const std::string firmware_filename
45
 
                                      ) throw (std::runtime_error)
46
 
  : gr_sync_block (name,
47
 
                   gr_make_io_signature (0, 0, 0),
48
 
                   output_signature),
49
 
    d_noverruns (0)
50
 
{
51
 
  d_usrp = usrp_standard_rx::make (which_board, decim_rate,
52
 
                                   nchan, mux, mode,
53
 
                                   fusb_block_size,
54
 
                                   fusb_nblocks,
55
 
                                   fpga_filename,
56
 
                                   firmware_filename);
57
 
  if (d_usrp == 0)
58
 
    throw std::runtime_error ("can't open usrp1");
59
 
 
60
 
  // All calls to d_usrp->read must be multiples of 512 bytes.
61
 
  // We jack this up to 4k to reduce overhead.
62
 
 
63
 
  set_output_multiple (OUTPUT_MULTIPLE_BYTES / output_signature->sizeof_stream_item (0));
64
 
}
65
 
 
66
 
usrp1_source_base::~usrp1_source_base ()
67
 
{
68
 
  delete d_usrp;
69
 
}
70
 
 
71
 
unsigned int
72
 
usrp1_source_base::sizeof_basic_sample() const
73
 
{
74
 
  return usrp_standard_rx::format_width(d_usrp->format()) / 8;
75
 
}
76
 
 
77
 
bool
78
 
usrp1_source_base::start()
79
 
{
80
 
  return d_usrp->start();
81
 
}
82
 
 
83
 
bool
84
 
usrp1_source_base::stop()
85
 
{
86
 
  return d_usrp->stop();
87
 
}
88
 
 
89
 
int
90
 
usrp1_source_base::work (int noutput_items,
91
 
                         gr_vector_const_void_star &input_items,
92
 
                         gr_vector_void_star &output_items)
93
 
{
94
 
  static const int BUFSIZE = 4 * OUTPUT_MULTIPLE_BYTES;
95
 
  unsigned char buf[BUFSIZE];
96
 
  int output_index = 0;
97
 
  int output_items_produced;
98
 
  int bytes_read;
99
 
  bool overrun;
100
 
 
101
 
  while (output_index < noutput_items){
102
 
    int nbytes = ninput_bytes_reqd_for_noutput_items (noutput_items - output_index);
103
 
    nbytes = std::min (nbytes, BUFSIZE);
104
 
 
105
 
    int result_nbytes = d_usrp->read (buf, nbytes, &overrun);
106
 
    if (overrun){
107
 
      // fprintf (stderr, "usrp1_source: overrun\n");
108
 
      fputs ("uO", stderr);
109
 
      d_noverruns++;
110
 
    }
111
 
 
112
 
    if (result_nbytes < 0)      // We've got a problem.  Usually board unplugged or powered down.
113
 
      return -1;                // Indicate we're done.
114
 
 
115
 
    if (result_nbytes != nbytes){       // not really an error, but unexpected
116
 
      fprintf (stderr, "usrp1_source: short read.  Expected %d, got %d\n",
117
 
               nbytes, result_nbytes);
118
 
    }
119
 
 
120
 
    copy_from_usrp_buffer (output_items,
121
 
                           output_index,
122
 
                           noutput_items - output_index,   // output_items_available
123
 
                           output_items_produced,          // [out]
124
 
                           buf,                            // usrp_buffer
125
 
                           result_nbytes,                  // usrp_buffer_length
126
 
                           bytes_read);                    // [out]
127
 
 
128
 
    assert (output_index + output_items_produced <= noutput_items);
129
 
    assert (bytes_read == result_nbytes);
130
 
 
131
 
    output_index += output_items_produced;
132
 
  }
133
 
 
134
 
  return noutput_items;
135
 
}
136
 
 
137
 
 
138
 
bool
139
 
usrp1_source_base::set_decim_rate (unsigned int rate)
140
 
{
141
 
  return d_usrp->set_decim_rate (rate);
142
 
}
143
 
 
144
 
bool
145
 
usrp1_source_base::set_nchannels (int nchan)
146
 
{
147
 
  return d_usrp->set_nchannels (nchan);
148
 
}
149
 
 
150
 
bool
151
 
usrp1_source_base::set_mux (int mux)
152
 
{
153
 
  return d_usrp->set_mux (mux);
154
 
}
155
 
 
156
 
bool
157
 
usrp1_source_base::set_rx_freq (int channel, double freq)
158
 
{
159
 
  return d_usrp->set_rx_freq (channel, freq);
160
 
}
161
 
 
162
 
long
163
 
usrp1_source_base::fpga_master_clock_freq() const
164
 
{
165
 
  return d_usrp->fpga_master_clock_freq();
166
 
}
167
 
 
168
 
long
169
 
usrp1_source_base::converter_rate() const
170
 
{
171
 
  return d_usrp->converter_rate();
172
 
}
173
 
 
174
 
unsigned int
175
 
usrp1_source_base::decim_rate () const
176
 
{
177
 
  return d_usrp->decim_rate ();
178
 
}
179
 
 
180
 
int
181
 
usrp1_source_base::nchannels () const
182
 
{
183
 
  return d_usrp->nchannels ();
184
 
}
185
 
 
186
 
int
187
 
usrp1_source_base::mux () const
188
 
{
189
 
  return d_usrp->mux ();
190
 
}
191
 
 
192
 
double
193
 
usrp1_source_base::rx_freq (int channel) const
194
 
{
195
 
  return d_usrp->rx_freq (channel);
196
 
}
197
 
 
198
 
bool
199
 
usrp1_source_base::set_fpga_mode (int mode)
200
 
{
201
 
  return d_usrp->set_fpga_mode (mode);
202
 
}
203
 
 
204
 
bool
205
 
usrp1_source_base::set_ddc_phase (int channel, int phase)
206
 
{
207
 
  return d_usrp->set_ddc_phase(channel, phase);
208
 
}
209
 
 
210
 
bool
211
 
usrp1_source_base::set_dc_offset_cl_enable(int bits, int mask)
212
 
{
213
 
  return d_usrp->set_dc_offset_cl_enable(bits, mask);
214
 
}
215
 
 
216
 
void
217
 
usrp1_source_base::set_verbose (bool verbose)
218
 
{  
219
 
  d_usrp->set_verbose (verbose);
220
 
}
221
 
 
222
 
bool
223
 
usrp1_source_base::write_aux_dac (int which_dboard, int which_dac, int value)
224
 
{
225
 
  return d_usrp->write_aux_dac (which_dboard, which_dac, value);
226
 
}
227
 
 
228
 
int
229
 
usrp1_source_base::read_aux_adc (int which_dboard, int which_adc)
230
 
{
231
 
  return d_usrp->read_aux_adc (which_dboard, which_adc);
232
 
}
233
 
 
234
 
bool
235
 
usrp1_source_base::write_eeprom (int i2c_addr, int eeprom_offset, const std::string buf)
236
 
{
237
 
  return d_usrp->write_eeprom (i2c_addr, eeprom_offset, buf);
238
 
}
239
 
 
240
 
std::string
241
 
usrp1_source_base::read_eeprom (int i2c_addr, int eeprom_offset, int len)
242
 
{
243
 
  return d_usrp->read_eeprom (i2c_addr, eeprom_offset, len);
244
 
}
245
 
 
246
 
bool
247
 
usrp1_source_base::write_i2c (int i2c_addr, const std::string buf)
248
 
{
249
 
  return d_usrp->write_i2c (i2c_addr, buf);
250
 
}
251
 
 
252
 
std::string
253
 
usrp1_source_base::read_i2c (int i2c_addr, int len)
254
 
{
255
 
  return d_usrp->read_i2c (i2c_addr, len);
256
 
}
257
 
 
258
 
bool
259
 
usrp1_source_base::set_pga (int which, double gain)
260
 
{
261
 
  return d_usrp->set_pga (which, gain);
262
 
}
263
 
 
264
 
double
265
 
usrp1_source_base::pga (int which) const
266
 
{
267
 
  return d_usrp->pga (which);
268
 
}
269
 
 
270
 
double
271
 
usrp1_source_base::pga_min () const
272
 
{
273
 
  return d_usrp->pga_min ();
274
 
}
275
 
 
276
 
double
277
 
usrp1_source_base::pga_max () const
278
 
{
279
 
  return d_usrp->pga_max ();
280
 
}
281
 
 
282
 
double
283
 
usrp1_source_base::pga_db_per_step () const
284
 
{
285
 
  return d_usrp->pga_db_per_step ();
286
 
}
287
 
 
288
 
int
289
 
usrp1_source_base::daughterboard_id (int which) const
290
 
{
291
 
  return d_usrp->daughterboard_id (which);
292
 
}
293
 
 
294
 
 
295
 
bool
296
 
usrp1_source_base::set_adc_offset (int which, int offset)
297
 
{
298
 
  return d_usrp->set_adc_offset (which, offset);
299
 
}
300
 
 
301
 
bool
302
 
usrp1_source_base::set_dac_offset (int which, int offset, int offset_pin)
303
 
{
304
 
  return d_usrp->set_dac_offset (which, offset, offset_pin);
305
 
}
306
 
 
307
 
bool
308
 
usrp1_source_base::set_adc_buffer_bypass (int which, bool bypass)
309
 
{
310
 
  return d_usrp->set_adc_buffer_bypass (which, bypass);
311
 
}
312
 
 
313
 
std::string
314
 
usrp1_source_base::serial_number()
315
 
{
316
 
  return d_usrp->serial_number();
317
 
}
318
 
 
319
 
bool
320
 
usrp1_source_base::_write_oe (int which_dboard, int value, int mask)
321
 
{
322
 
  return d_usrp->_write_oe (which_dboard, value, mask);
323
 
}
324
 
 
325
 
bool
326
 
usrp1_source_base::write_io (int which_dboard, int value, int mask)
327
 
{
328
 
  return d_usrp->write_io (which_dboard, value, mask);
329
 
}
330
 
 
331
 
int
332
 
usrp1_source_base::read_io (int which_dboard)
333
 
{
334
 
  return d_usrp->read_io (which_dboard);
335
 
}
336
 
 
337
 
 
338
 
 
339
 
 
340
 
// internal routines...
341
 
 
342
 
bool
343
 
usrp1_source_base::_write_fpga_reg (int regno, int value)
344
 
{
345
 
  return d_usrp->_write_fpga_reg (regno, value);
346
 
}
347
 
 
348
 
bool
349
 
usrp1_source_base::_write_fpga_reg_masked (int regno, int value, int mask)
350
 
{
351
 
  return d_usrp->_write_fpga_reg_masked (regno, value, mask);
352
 
}
353
 
 
354
 
int
355
 
usrp1_source_base::_read_fpga_reg (int regno)
356
 
{
357
 
  return d_usrp->_read_fpga_reg (regno);
358
 
}
359
 
 
360
 
bool
361
 
usrp1_source_base::_write_9862 (int which_codec, int regno, unsigned char value)
362
 
{
363
 
  return d_usrp->_write_9862 (which_codec, regno, value);
364
 
}
365
 
 
366
 
int
367
 
usrp1_source_base::_read_9862 (int which_codec, int regno) const
368
 
{
369
 
  return d_usrp->_read_9862 (which_codec, regno);
370
 
}
371
 
 
372
 
bool
373
 
usrp1_source_base::_write_spi (int optional_header, int enables,
374
 
                               int format, std::string buf)
375
 
{
376
 
  return d_usrp->_write_spi (optional_header, enables, format, buf);
377
 
}
378
 
 
379
 
std::string
380
 
usrp1_source_base::_read_spi (int optional_header, int enables, int format, int len)
381
 
{
382
 
  return d_usrp->_read_spi (optional_header, enables, format, len);
383
 
}
384
 
 
385
 
bool
386
 
usrp1_source_base::set_format(unsigned int format)
387
 
{
388
 
  return d_usrp->set_format(format);
389
 
}
390
 
 
391
 
unsigned int
392
 
usrp1_source_base::format() const
393
 
{
394
 
  return d_usrp->format();
395
 
}
396
 
 
397
 
unsigned int
398
 
usrp1_source_base::make_format(int width, int shift, bool want_q, bool bypass_halfband)
399
 
{
400
 
  return usrp_standard_rx::make_format(width, shift, want_q, bypass_halfband);
401
 
}
402
 
 
403
 
int
404
 
usrp1_source_base::format_width(unsigned int format)
405
 
{
406
 
  return usrp_standard_rx::format_width(format);
407
 
}
408
 
 
409
 
int
410
 
usrp1_source_base::format_shift(unsigned int format)
411
 
{
412
 
  return usrp_standard_rx::format_shift(format);
413
 
}
414
 
 
415
 
bool
416
 
usrp1_source_base::format_want_q(unsigned int format)
417
 
{
418
 
  return usrp_standard_rx::format_want_q(format);
419
 
}
420
 
 
421
 
bool
422
 
usrp1_source_base::format_bypass_halfband(unsigned int format)
423
 
{
424
 
  return usrp_standard_rx::format_bypass_halfband(format);
425
 
}