Example #1
0
File: op25.py Project: RegWd/gr-baz
 def __init__(self, traffic_msgq=None, key=None):
     gr.hier_block2.__init__(self, "op25_decoder",
                           gr.io_signature(1, 1, gr.sizeof_float),
                           gr.io_signature(1, 1, gr.sizeof_float))
     
     self.traffic_msgq = traffic_msgq
     self.key = key
     
     if self.traffic_msgq is None:
         self.traffic_msgq = gr.msg_queue(2)
     
     self.slicer = None
     try:
         levels = [ -2.0, 0.0, 2.0, 4.0 ]
         self.slicer = _op25.fsk4_slicer_fb(levels)
         self.p25_decoder = _op25.decoder_bf()
         self.p25_decoder.set_msgq(self.traffic_msgq)
         if _verbose:
             print "Using new decoder_bf"
     except:
         try:
             self.p25_decoder = _op25.decoder_ff(self.traffic_msgq)   # LEGACY
             if _verbose:
                 print "Using legacy decoder_ff"
         except:
             raise Exception("Could not find a decoder to use")
     
     if (self.key is not None) and (len(self.key) > 0): # Relates to key string passed in from GRC block
         self.set_key(self.key)
     
     if self.slicer:
         self.connect(self, self.slicer, self.p25_decoder)
     else:
         self.connect(self, self.p25_decoder)
     self.connect(self.p25_decoder, self)
Example #2
0
    def __init__(self, traffic_msgq=None, key=None):
        gr.hier_block2.__init__(self, "op25_decoder",
                                gr.io_signature(1, 1, gr.sizeof_float),
                                gr.io_signature(1, 1, gr.sizeof_float))

        self.traffic_msgq = traffic_msgq
        self.key = key

        if self.traffic_msgq is None:
            self.traffic_msgq = gr.msg_queue(2)

        self.slicer = None
        try:
            levels = [-2.0, 0.0, 2.0, 4.0]
            self.slicer = _op25.fsk4_slicer_fb(levels)
            self.p25_decoder = _op25.decoder_bf()
            self.p25_decoder.set_msgq(self.traffic_msgq)
            if _verbose:
                print "Using new decoder_bf"
        except:
            try:
                self.p25_decoder = _op25.decoder_ff(
                    self.traffic_msgq)  # LEGACY
                if _verbose:
                    print "Using legacy decoder_ff"
            except:
                raise Exception("Could not find a decoder to use")

        if (self.key is not None) and (
                len(self.key) >
                0):  # Relates to key string passed in from GRC block
            self.set_key(self.key)

        if self.slicer:
            self.connect(self, self.slicer, self.p25_decoder)
        else:
            self.connect(self, self.p25_decoder)
        self.connect(self.p25_decoder, self)
Example #3
0
    def create(self):
        self.op25_msgq = gr.msg_queue(2)
        self.slicer = None
        try:
            levels = [ -2.0, 0.0, 2.0, 4.0 ]
            self.slicer = _op25.fsk4_slicer_fb(levels)
            self.p25_decoder = _op25.decoder_bf()   # FIXME: Message queue?
            if _verbose:
				print "Using new decoder_bf"
        except:
            try:
                self.p25_decoder = _op25.decoder_ff(self.op25_msgq)   # LEGACY
                if _verbose:
					print "Using legacy decoder_ff"
            except:
                raise Exception("Could not find a decoder to use")
        
        # Reference code
        #self.decode_watcher = decode_watcher(self.op25_msgq, self.traffic)
        
        if (self.key is not None) and (len(self.key) > 0): # Relates to key string passed in from GRC block
            self.set_key(self.key)
        
        # Reference code
        #trans_width = 12.5e3 / 2;
        #trans_centre = trans_width + (trans_width / 2)
        # discriminator tap doesn't do freq. xlation, FM demodulation, etc.
        #    coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN)
        #    self.channel_filter = gr.freq_xlating_fir_filter_ccf(channel_decim, coeffs, 0.0, capture_rate)
        #    self.set_channel_offset(0.0, 0, self.spectrum.win._units)
        #    # power squelch
        #    squelch_db = 0
        #    self.squelch = gr.pwr_squelch_cc(squelch_db, 1e-3, 0, True)
        #    self.set_squelch_threshold(squelch_db)
        #    # FM demodulator
        #    fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation)
        #    fm_demod = gr.quadrature_demod_cf(fm_demod_gain)
        # symbol filter        
        #symbol_decim = 1
        #symbol_coeffs = gr.firdes.root_raised_cosine(1.0, channel_rate, self.symbol_rate, 0.2, 500)
        # boxcar coefficients for "integrate and dump" filter
        #samples_per_symbol = channel_rate // self.symbol_rate
        #symbol_duration = float(self.symbol_rate) / channel_rate
        #print "Symbol duration:", symbol_duration
        #print "Samples per symbol:", samples_per_symbol
        #symbol_coeffs = (1.0/samples_per_symbol,)*samples_per_symbol
        #self.symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs)
        
        # C4FM demodulator
        #print "Symbol rate:", self.symbol_rate
        if self.auto_tune_msgq is None:
            self.auto_tune_msgq = gr.msg_queue(2)
        try:
            self.demod_fsk4 = _op25.fsk4_demod_ff(self.auto_tune_msgq, self.channel_rate, self.symbol_rate)
            if _verbose:
				print "Using new fsk4_demod_ff"
        except:
            try:
                self.demod_fsk4 = fsk4.demod_ff(self.auto_tune_msgq, self.channel_rate, self.symbol_rate)   # LEGACY
                if _verbose:
					print "Using legacy fsk4.demod_ff"
            except:
                raise Exception("Could not find a FSK4 demodulator to use")
        
        # Reference code
        #self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset)
        #list = [[self, self.channel_filter, self.squelch, fm_demod, self.symbol_filter, demod_fsk4, self.p25_decoder, self.sink]]
        
        self.connect(self, self.demod_fsk4)
        if self.slicer:
            self.connect(self.demod_fsk4, self.slicer)
            self.connect(self.slicer, self.p25_decoder)
        else:
            self.connect(self.demod_fsk4, self.p25_decoder)
        self.connect(self.p25_decoder, (self, 0))
        
        if self.output_dibits:
            self.connect(self.demod_fsk4, (self, 1))
Example #4
0
    def create(self):
        self.op25_msgq = gr.msg_queue(2)
        self.slicer = None
        try:
            levels = [-2.0, 0.0, 2.0, 4.0]
            self.slicer = _op25.fsk4_slicer_fb(levels)
            self.p25_decoder = _op25.decoder_bf()  # FIXME: Message queue?
            if _verbose:
                print "Using new decoder_bf"
        except:
            try:
                self.p25_decoder = _op25.decoder_ff(self.op25_msgq)  # LEGACY
                if _verbose:
                    print "Using legacy decoder_ff"
            except:
                raise Exception("Could not find a decoder to use")

        # Reference code
        #self.decode_watcher = decode_watcher(self.op25_msgq, self.traffic)

        if (self.key is not None) and (
                len(self.key) >
                0):  # Relates to key string passed in from GRC block
            self.set_key(self.key)

        # Reference code
        #trans_width = 12.5e3 / 2;
        #trans_centre = trans_width + (trans_width / 2)
        # discriminator tap doesn't do freq. xlation, FM demodulation, etc.
        #    coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN)
        #    self.channel_filter = gr.freq_xlating_fir_filter_ccf(channel_decim, coeffs, 0.0, capture_rate)
        #    self.set_channel_offset(0.0, 0, self.spectrum.win._units)
        #    # power squelch
        #    squelch_db = 0
        #    self.squelch = gr.pwr_squelch_cc(squelch_db, 1e-3, 0, True)
        #    self.set_squelch_threshold(squelch_db)
        #    # FM demodulator
        #    fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation)
        #    fm_demod = gr.quadrature_demod_cf(fm_demod_gain)
        # symbol filter
        #symbol_decim = 1
        #symbol_coeffs = gr.firdes.root_raised_cosine(1.0, channel_rate, self.symbol_rate, 0.2, 500)
        # boxcar coefficients for "integrate and dump" filter
        #samples_per_symbol = channel_rate // self.symbol_rate
        #symbol_duration = float(self.symbol_rate) / channel_rate
        #print "Symbol duration:", symbol_duration
        #print "Samples per symbol:", samples_per_symbol
        #symbol_coeffs = (1.0/samples_per_symbol,)*samples_per_symbol
        #self.symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs)

        # C4FM demodulator
        #print "Symbol rate:", self.symbol_rate
        if self.auto_tune_msgq is None:
            self.auto_tune_msgq = gr.msg_queue(2)
        try:
            self.demod_fsk4 = _op25.fsk4_demod_ff(self.auto_tune_msgq,
                                                  self.channel_rate,
                                                  self.symbol_rate)
            if _verbose:
                print "Using new fsk4_demod_ff"
        except:
            try:
                self.demod_fsk4 = fsk4.demod_ff(self.auto_tune_msgq,
                                                self.channel_rate,
                                                self.symbol_rate)  # LEGACY
                if _verbose:
                    print "Using legacy fsk4.demod_ff"
            except:
                raise Exception("Could not find a FSK4 demodulator to use")

        # Reference code
        #self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset)
        #list = [[self, self.channel_filter, self.squelch, fm_demod, self.symbol_filter, demod_fsk4, self.p25_decoder, self.sink]]

        self.connect(self, self.demod_fsk4)
        if self.slicer:
            self.connect(self.demod_fsk4, self.slicer)
            self.connect(self.slicer, self.p25_decoder)
        else:
            self.connect(self.demod_fsk4, self.p25_decoder)
        self.connect(self.p25_decoder, (self, 0))

        if self.output_dibits:
            self.connect(self.demod_fsk4, (self, 1))