Houston, we have a trunk.

git-svn-id: http://gnuradio.org/svn/gnuradio/trunk@3122 221aa14e-8319-0410-a670-987f0aec2ac5

1 files changed, 198 insertions, 0 deletions

diff --git a/gr-usrp/src/db_tv_rx.py b/gr-usrp/src/db_tv_rx.py
new file mode 100644
index 000000000..05504553a
--- /dev/null
+++ b/gr-usrp/src/db_tv_rx.py
@@ -0,0 +1,198 @@
+#
+# Copyright 2005 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 2, 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., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+# 
+
+__all__ = ['tv_rx']
+
+import math
+import usrp_dbid
+import db_base
+import db_instantiator
+
+def int_seq_to_str(seq):
+    """convert a sequence of integers into a string"""
+    return ''.join (map (chr, seq))
+
+def str_to_int_seq(str):
+    """convert a string to a list of integers"""
+    return map (ord, str)
+
+def control_byte_1(fast_tuning_p, reference_divisor):
+    c = 0x88
+    if fast_tuning_p:
+        c |= 0x40
+    if reference_divisor == 512:
+        c |= 0x3 << 1
+    elif reference_divisor == 640:
+        c |= 0x0 << 1
+    elif reference_divisor == 1024:
+        c |= 0x1 << 1
+    else:
+        assert 0
+    return c
+
+def control_byte_2(target_freq, shutdown_tx_PGA):
+    if target_freq < 158e6:        # VHF low
+        c = 0xa0
+    elif target_freq < 464e6:      # VHF high
+        c = 0x90
+    else:                          # UHF
+        c = 0x30
+    if shutdown_tx_PGA:
+        c |= 0x08
+    return c
+
+class db_tv_rx(db_base.db_base):
+    def __init__(self, usrp, which, first_IF, second_IF):
+        """
+        Control Microtune 4937 based USRP daughterboard.
+        
+        @param usrp: instance of usrp.source_c
+        @param which: which side: 0 or 1 corresponding to RX_A or RX_B respectively
+        @type which: int
+        """
+        # sets _u and _which
+        db_base.db_base.__init__(self, usrp, which)
+
+        self._i2c_addr = (0x60, 0x61)[which]
+
+        self._first_IF = first_IF
+        self._second_IF = second_IF
+        self._reference_divisor = 640
+        self._fast_tuning = False
+        self._inverted = False      # FIXME get rid of this
+        
+        g = self.gain_range()                  # initialize gain
+        self.set_gain(float(g[0]+g[1]) / 2)
+
+        self.bypass_adc_buffers(False)
+        
+    # Gain setting
+    def _set_rfagc(self,gain):
+        assert gain <= 60 and gain >= 0
+        # FIXME this has a 0.5V step between gain = 60 and gain = 59.
+        # Why are there two cases instead of a single linear case?
+        if gain == 60:
+            voltage = 4
+        else:
+            voltage = gain/60.0 * 2.25 + 1.25
+        dacword = int(4096*voltage/1.22/3.3)    # 1.22 = opamp gain
+
+        assert dacword>=0 and dacword<4096
+        self._u.write_aux_dac(self._which, 1, dacword)
+
+    def _set_ifagc(self,gain):
+        assert gain <= 35 and gain >= 0
+        voltage = gain/35.0 * 2.1 + 1.4
+        dacword = int(4096*voltage/1.22/3.3)    # 1.22 = opamp gain
+
+        assert dacword>=0 and dacword<4096
+        self._u.write_aux_dac(self._which, 0, dacword)
+
+    def _set_pga(self,pga_gain):
+        assert pga_gain >=0 and pga_gain <=20
+        if(self._which == 0):
+            self._u.set_pga (0, pga_gain)
+        else:
+            self._u.set_pga (2, pga_gain)
+            
+    def gain_range(self):
+        return (0, 115, 1)
+    
+    def set_gain(self,gain):
+        assert gain>=0 and gain<=115
+        if gain>60:
+            rfgain = 60
+            gain = gain - 60
+        else:
+            rfgain = gain
+            gain = 0
+        if gain > 35:
+            ifgain = 35
+            gain = gain - 35
+        else:
+            ifgain = gain
+            gain = 0
+        pgagain = gain
+        self._set_rfagc(rfgain)
+        self._set_ifagc(ifgain)
+        self._set_pga(pgagain)
+        
+    def freq_range(self):
+        return (50e6, 860e6, 10e3)
+
+    def set_freq(self, target_freq):
+        """
+        @returns (ok, actual_baseband_freq) where:
+           ok is True or False and indicates success or failure,
+           actual_baseband_freq is the RF frequency that corresponds to DC in the IF.
+        """
+        r = self.freq_range()
+        if target_freq < r[0] or target_freq > r[1]:
+            return (False, 0)
+        
+        target_lo_freq = target_freq + self._first_IF;  # High side mixing
+        f_ref = 4e6 / self._reference_divisor   # frequency steps
+
+        divisor = int((target_lo_freq + (f_ref * 4)) / (f_ref * 8))  
+        actual_lo_freq = (f_ref * 8 * divisor)
+        actual_freq = actual_lo_freq - self._first_IF;
+
+        if (divisor & ~0x7fff) != 0:		# must be 15-bits or less
+            return (False, 0)
+        
+        # build i2c command string
+        buf = [0] * 4
+        buf[0] = (divisor >> 8) & 0xff          # DB1
+        buf[1] = divisor & 0xff                 # DB2
+        buf[2] = control_byte_1(self._fast_tuning, self._reference_divisor)
+        buf[3] = control_byte_2(actual_freq, True)  
+
+        ok = self._u.write_i2c(self._i2c_addr, int_seq_to_str (buf))
+
+        return (ok, actual_freq - self._second_IF)
+
+    def is_quadrature(self):
+        """
+        Return True if this board requires both I & Q analog channels.
+
+        This bit of info is useful when setting up the USRP Rx mux register.
+        """
+        return False
+
+    def spectrum_inverted(self):
+        """
+        The 43.75 MHz version is inverted
+        """
+        return self._inverted
+
+# hook this daughterboard class into the auto-instantiation framework
+
+# With MT4937DI5-3x7702 with second downconversion
+db_instantiator.add(usrp_dbid.TV_RX,
+                    lambda usrp, which : (db_tv_rx(usrp, which, 43.75e6, 5.75e6),))
+
+# With MT4937DI5-3x8680, and 3x8769 without second downconversion
+db_instantiator.add(usrp_dbid.TV_RX_REV_2,
+                    lambda usrp, which : (db_tv_rx(usrp, which, 44e6, 20e6),))
+
+# With MT4937DI5-3x7901 without second downconversion, basically the same as tvrx2
+db_instantiator.add(usrp_dbid.TV_RX_REV_3,
+                    lambda usrp, which : (db_tv_rx(usrp, which, 44e6, 20e6),))