git.gag.com Git - debian/gnuradio/blob - usrp/host/lib/inband/usrp_rx.cc

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2007 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 along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <usrp_rx.h>
  27
  28 #include <usrp_standard.h>
  29 #include <iostream>
  30 #include <vector>
  31 #include <usb.h>
  32 #include <mb_class_registry.h>
  33 #include <usrp_inband_usb_packet.h>
  34 #include <fpga_regs_common.h>
  35 #include <stdio.h>
  36
  37 #include <symbols_usrp_rx_cs.h>
  38
  39 typedef usrp_inband_usb_packet transport_pkt;
  40
  41 static const bool verbose = false;
  42
  43 bool usrp_rx_stop;
  44
  45 usrp_rx::usrp_rx(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg)
  46   : mb_mblock(rt, instance_name, user_arg),
  47     d_disk_write(false),
  48     d_disk_write_pkt(false)   // if true, writes full packet, else just the payload
  49 {
  50   d_cs = define_port("cs", "usrp-rx-cs", true, mb_port::EXTERNAL);
  51
  52   if(d_disk_write) {
  53     d_ofile0.open("rx_data_chan0.dat",std::ios::binary|std::ios::out);
  54     d_ofile1.open("rx_data_chan1.dat",std::ios::binary|std::ios::out);
  55     d_cs_ofile.open("rx_cs.dat",std::ios::binary|std::ios::out);
  56   }
  57
  58   usrp_rx_stop = false;
  59
  60 }
  61
  62 usrp_rx::~usrp_rx()
  63 {
  64   if(d_disk_write) {
  65     d_ofile0.close();
  66     d_ofile1.close();
  67     d_cs_ofile.close();
  68   }
  69 }
  70
  71 void
  72 usrp_rx::initial_transition()
  73 {
  74
  75 }
  76
  77 /*!
  78  * \brief Handles incoming signals to to the m-block, wihch should only ever be
  79  * a single message: cmd-usrrp-rx-start-reading.  There is no signal to stop
  80  * reading as the m-block goes in to a forever loop to read inband packets from
  81  * the bus.
  82  */
  83 void
  84 usrp_rx::handle_message(mb_message_sptr msg)
  85 {
  86   pmt_t event = msg->signal();
  87   pmt_t port_id = msg->port_id();
  88   pmt_t data = msg->data();
  89
  90   // Theoretically only have 1 message to ever expect, but
  91   // want to make sure its at least what we want
  92   if(pmt_eq(port_id, d_cs->port_symbol())) {
  93
  94     if(pmt_eqv(event, s_cmd_usrp_rx_start_reading))
  95       read_and_respond(data);
  96   }
  97 }
  98
  99 /*!
 100  * \brief Performs the actual reading of data from the USB bus, called by
 101  * handle_message() when a cmd-usrp-rx-start-reading signal is received.
 102  *
 103  * The method enters a forever loop where it continues to read data from the bus
 104  * and generate read responses to the higher layer.  Currently, shared memory is
 105  * used to exit this loop.
 106  *
 107  * The \p data parameter is a PMT list which contains only a single element, an
 108  * invocation handle which will be returned with all read respones.
 109  */
 110 void
 111 usrp_rx::read_and_respond(pmt_t data)
 112 {
 113   size_t ignore;
 114   bool underrun;
 115   unsigned int n_read;
 116   unsigned int pkt_size = sizeof(transport_pkt);
 117
 118   pmt_t invocation_handle = pmt_nth(0, data);
 119
 120   // Need the handle to the RX port to send responses, this is passed
 121   // by the USRP interface m-block
 122   d_urx =
 123     boost::any_cast<usrp_standard_rx *>(pmt_any_ref(pmt_nth(1, data)));
 124
 125   if(verbose)
 126     std::cout << "[usrp_rx] Waiting for packets..\n";
 127
 128   // Read by 512 which is packet size and send them back up
 129   while(!usrp_rx_stop) {
 130
 131     pmt_t v_pkt = pmt_make_u8vector(pkt_size, 0);
 132     transport_pkt *pkt =
 133       (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, ignore);
 134
 135     n_read = d_urx->read(pkt, pkt_size, &underrun);
 136
 137     if(n_read != pkt_size) {
 138       std::cerr << "[usrp_rx] Error reading packet, shutting down\n";
 139       d_cs->send(s_response_usrp_rx_read,
 140                  pmt_list3(PMT_NIL, PMT_F, PMT_NIL));
 141       return;
 142     }
 143
 144     if(underrun && verbose && 0)
 145       std::cout << "[usrp_rx] Underrun\n";
 146
 147     d_cs->send(s_response_usrp_rx_read,
 148                pmt_list3(PMT_NIL, PMT_T, v_pkt));
 149     if(verbose && 0)
 150       std::cout << "[usrp_rx] Read 1 packet\n";
 151
 152     if(d_disk_write) {
 153       if(pkt->chan() == CONTROL_CHAN)
 154         d_cs_ofile.write((const char *)pkt, transport_pkt::max_pkt_size());
 155       else {
 156         if(d_disk_write_pkt) {
 157           if(pkt->chan() == 0)
 158             d_ofile0.write((const char *)pkt, transport_pkt::max_pkt_size());
 159           else if(pkt->chan() == 1)
 160             d_ofile1.write((const char *)pkt, transport_pkt::max_pkt_size());
 161         } else {
 162           if(pkt->chan() == 0)
 163             d_ofile0.write((const char *)pkt->payload(), transport_pkt::max_payload());
 164           else if(pkt->chan() == 1)
 165             d_ofile1.write((const char *)pkt->payload(), transport_pkt::max_payload());
 166         }
 167       }
 168
 169       d_cs_ofile.flush();
 170       d_ofile0.flush();
 171       d_ofile1.flush();
 172     }
 173   }
 174
 175   usrp_rx_stop = false;
 176
 177   if(verbose) {
 178     std::cout << "[USRP_RX] Stopping...\n";
 179     fflush(stdout);
 180   }
 181 }
 182
 183 REGISTER_MBLOCK_CLASS(usrp_rx);