def __init__(self, args): super(Shad0wC2, self).__init__() # declare all the vitial variables to run. self.addr = (args['address'], args['port']) self.debugv = args['debug'] self.sslkey = args['key'] self.sslcrt = args['cert'] # website we can mirror self.mirror = args['mirror'] # endpoint for modules to callback to self.endpoint = args['endpoint'] # runtime variables self.beacons = {} self.beacon_count = 0 self.current_beacon = None # get the debug/logging stuff ready self.debug = debug.Debug(self.debugv) # console class self.console = console.Console(self) # super useful self.crypt = encryption
def on(self): ModeShell.on(self) self.tb.lock() if self.tx_vol is not None: print '@@@@@ connecting tx blocks;' #self.tx_tmp = blocks.null_source(4) #self.connect(self.tx_tmp, self.tx_vol, (self.tx_ftc, 0)) self.connect(self.audio_rx, self.tx_vol, (self.tx_ftc, 0)) self.connect(self.tx_cnst_src, (self.tx_ftc, 1)) self.connect(self.tx_ftc, self.tx_ssb_shifter_mul, self.tx_lpf, self.tx_if0_mul) #self.connect(self.tx_if0_mul, debug.Debug(xtype=numpy.dtype(numpy.complex64), tag='FROM TX LAST BLOCK')) self.tx_disconnect_node = self.tx.connect(txblock=self.tx_if0_mul, pwrprimon=self.txpwrpri) if self.rx_if0_mul is not None: self.connect(self.rx, self.rx_if0_mul, self.rx_lpf, self.rx_cms, self.rx_vol) self.connect( self.rx, debug.Debug(xtype=numpy.dtype(numpy.complex64), tag='FROM RX FIRST BLOCK')) self.connect(self.rx_cms, self.rx_sigstr) self.audio_disconnect_node = self.audio_tx.connect( txblock=self.rx_vol, pwrprimon=self.volpwrpri) self.tb.unlock() self.chanover.change_active(True)
def __init__(self, args): super(Shad0wBuilder, self).__init__() # key variables for the build self.address = args['address'] self.port = args['port'] self.jitter = args['jitter'] self.format = args['format'] self.outfile = args['out'] self.debugv = args['debug'] # get the debug/logging stuff ready self.debug = debug.Debug(self.debugv)
def __init__(self, args): super(Shad0wC2, self).__init__() # payload store self.payloads = {} # declare all the vitial variables to run. self.addr = (args['address'], args['port']) self.debugv = args['debug'] self.sslkey = args['key'] self.sslcrt = args['cert'] # framework variables self.variables = {} # set the msf callback size self.variables["MsfUriSize"] = 1337 # website we can mirror self.mirror = args['mirror'] # endpoint for modules to callback to self.endpoint = args['endpoint'] # runtime variables self.beacons = {} self.beacon_count = 0 self.current_beacon = None # loading screen stuff self.screen_finish = False # get the debug/logging stuff ready self.debug = debug.Debug(self.debugv) # console class self.console = console.Console(self) # super useful self.crypt = encryption
def __init__(self): qtgui4.QWidget.__init__(self) self.tb = gr.top_block() self.tb.lockdepth = 0 self.tb.lastunlock = 0 # TODO: see if speed locking can still actually lock # but just use no timeout # # INFO: the timeout is a workaround for the USRP which # can not handle the fast locking and unlocking def __checkdelaylocking(self): if time.time() - self.tb.lastunlock < 1.0: time.sleep(0.1) self.tb.lastunlock = time.time() def __unlock(self): tident = threading.current_thread().ident print 'top_block unlock called by thread:%s' % tident self.lockdepth -= 1 if self.lockdepth == 0: print 'UNLOCKED' self.old_unlock() def __lock(self): tident = threading.current_thread().ident print 'top_block LOCK called by thread:%s' % tident if self.lockdepth == 0: time.sleep(0.1) self.old_lock() time.sleep(0.1) self.lockdepth += 1 def __connect(self, *args): tident = threading.current_thread().ident for x in xrange(1, len(args)): a = args[x - 1] b = args[x] sys.stderr.write('CONNECT %s -> %s\n' % (a, b)) self.old_connect(*args) def __disconnect(self, a, b, guard=False): self.old_disconnect(a, b) sys.stderr.write('DISCONNECT %s -> %s\n' % (a, b)) #if guard is False: # raise Exception('@@@') setattr(self.tb, 'old_disconnect', self.tb.disconnect) setattr(self.tb, 'disconnect', types.MethodType(__disconnect, self.tb)) setattr(self.tb, 'old_unlock', self.tb.unlock) setattr(self.tb, 'unlock', types.MethodType(__unlock, self.tb)) setattr(self.tb, 'old_lock', self.tb.lock) setattr(self.tb, 'lock', types.MethodType(__lock, self.tb)) setattr(self.tb, 'old_connect', self.tb.connect) setattr(self.tb, 'connect', types.MethodType(__connect, self.tb)) self.lmidr = qtgui4.QWidget(self) self.top = qtgui4.QWidget(self) self.middle = qfastfft.QFastFFT(tb=self.tb) self.qfft = self.middle self.left = qtgui4.QWidget(self.lmidr) self.right = qtgui4.QWidget(self.lmidr) self.left_upper = qtgui4.QWidget(self.right) self.right_upper = qtgui4.QWidget(self.right) self.left_bottom = qtgui4.QWidget(self.left) self.right_bottom = qtgui4.QWidget(self.left) self.mode_select = qtgui4.QComboBox() self.enable_channel = qtgui4.QPushButton("Toggle") self.mode_select.setParent(self.left_upper) self.enable_channel.setParent(self.left_upper) chan_count = 4 self.q_map = chanoverview.ChanOverview(chan_count) self.left_upper.setParent(self.left) self.left_bottom.setParent(self.left) self.middle.setParent(self.lmidr) self.q_map.setParent(self.left_upper) self.q_map.move(0, 0) self.resize(1280, 800) self.right.move(0, 0) self.left.move(0, 0) self.middle.move(100, 0) self.top.move(0, 0) self.lmidr.move(0, 50) self.left_upper.move(0, 0) self.left_bottom.move(0, 125) self.right_upper.move(0, 0) self.right_bottom.move(0, 200) self.top.resize(1280, 50) yrem = 800 - 50 self.lmidr.resize(1280, yrem) self.middle.resize(1280 - 100, 700) self.right.resize(0, 0) self.right_upper.resize(100, 100) self.q_map.resize(100, 100) self.right_bottom.resize(150, 300) self.mode_select.move(0, 100) self.mode_select.resize(50, 25) self.enable_channel.move(50, 100) self.enable_channel.resize(50, 25) self.left.resize(100, yrem) self.left_upper.resize(100, 120) self.left_bottom.resize(100, yrem - 300) self.right_upper.hide() self.right_bottom.hide() self.right.hide() for k in ['AM', 'FM']: self.mode_select.addItem(k) def __enable_clicked(): chan = self.get_cur_vchan() if chan.is_on(): chan.off() else: chan.on() self.enable_channel.clicked.connect(__enable_clicked) #quick_layout(self.left, [ # self.left_upper, self.left_bottom #], horizontal=False) self.q_ccndx = qtgui4.QLCDNumber(3) self.top.setMaximumSize(1100, 100) def change_freq(dev, value): dev.set_center_freq(value) self.update_all_channels() def change_gain(dev, value): # TODO: check maximum gain levels of device # used and also check since they are # different per RX and TX if value > 73: # OK, for USRP B200 value = 73 dev.set_gain(value) self.update_all_channels() def change_bw(dev, value): dev.set_bandwidth(value) self.update_all_channels() def change_sps(dev, value): print 'SPS SET for %s to %s' % (dev, value) dev.set_samp_rate(value) self.update_all_channels() def change_vol(value): pass def change_chan(value): self.set_cur_vchan(value) # TODO: match below in controls for default to reduce programmer bugs start_sps = 16000 * 4 self.qfft.set_sps(start_sps) self.q_rx_cfreq = qlcdnumberadjustable.QLCDNumberAdjustable( label='RX FREQ', digits=12, signal=lambda v: change_freq(self.rx, v), xdef=146410000) self.q_rx_gain = qlcdnumberadjustable.QLCDNumberAdjustable( label='RX GAIN', digits=2, signal=lambda v: change_gain(self.rx, v), xdef=70) self.q_rx_bw = qlcdnumberadjustable.QLCDNumberAdjustable( label='RX BW', digits=9, signal=lambda v: change_bw(self.rx, v), xdef=63500) self.q_rx_sps = qlcdnumberadjustable.QLCDNumberAdjustable( label='RX SPS', digits=4, mul=16000, signal=lambda v: change_sps(self.rx, v), xdef=4) self.q_tx_cfreq = qlcdnumberadjustable.QLCDNumberAdjustable( label='TX FREQ', digits=12, xdef=146410000, signal=lambda v: change_freq(self.btx, v)) self.q_tx_gain = qlcdnumberadjustable.QLCDNumberAdjustable( label='TX GAIN', digits=2, xdef=0, signal=lambda v: change_gain(self.btx, v)) self.q_tx_bw = qlcdnumberadjustable.QLCDNumberAdjustable( label='TX BW', digits=9, xdef=63500, signal=lambda v: change_bw(self.btx, v)) self.q_tx_sps = qlcdnumberadjustable.QLCDNumberAdjustable( label='TX SPS', digits=4, mul=16000, xdef=4, signal=lambda v: change_sps(self.btx, v)) self.q_vol = qlcdnumberadjustable.QLCDNumberAdjustable( label='VOL', digits=2, signal=change_vol, xdef=50) self.q_tx_pwr_max = qlcdnumberadjustable.QLCDNumberAdjustable( label='TX PWR MAX', digits=3, signal=change_vol, xdef=50, max=100) self.q_chan = qlcdnumberadjustable.QLCDNumberAdjustable( label='CHAN', digits=2, signal=change_chan, xdef=0, max=chan_count - 1) self.top.lay = quick_layout(self.top, [ self.q_rx_cfreq, self.q_rx_gain, self.q_rx_bw, self.q_rx_sps, self.q_tx_cfreq, self.q_tx_gain, self.q_tx_bw, self.q_tx_sps, self.q_vol, self.q_chan, self.q_tx_pwr_max ]) ''' Initialize the independent RX source and TX sink or emulate them as being independent if only half-duplex. ''' self.rx = uhd.usrp_source(device_addr='', stream_args=uhd.stream_args('fc32')) self.rx.set_center_freq(self.q_rx_cfreq.get_value()) self.rx.set_bandwidth(self.q_rx_bw.get_value()) self.rx.set_gain(73) self.rx.set_antenna('RX2') self.rx.set_samp_rate(self.q_rx_sps.get_value()) self.btx = uhd.usrp_sink(device_addr='', stream_args=uhd.stream_args('fc32')) self.btx.set_center_freq(self.q_tx_cfreq.get_value()) self.btx.set_bandwidth(self.q_tx_bw.get_value()) self.btx.set_gain(1) self.btx.set_antenna('TX/RX') self.btx.set_samp_rate(self.q_tx_sps.get_value()) #self.btx = debug.Debug(numpy.dtype(numpy.complex64), tag='USRPTX') #self.btx = blocks.file_sink(8, '/home/kmcguire/dump.test') self.tx = LimiterMultiplexer(tb=self.tb, dtype=numpy.complex64, dtsize=8, maxinputs=8) self.tb.connect(self.tx, self.btx) def __tick_tx(): # This tick allows the transmit multiplexer to calculate # power allocates and adjust the limiter and gates so that # each channel can transmit using a certain percentage of # the total avaliable power without flucuations. This ticks # at a low speed. self.tx.tick() # Also, the audio sink is multiplexed exactly the same, but it # uses a float-32, of of this moment, type in the stream instead # of a complex-64 item type. self.audio_sink.tick() def __tick_qmap(): # This allows the channel overview to perform any needed # updates. It ticks at a moderate speed. self.q_map.tick() self.tx_tick = qtcore4.QTimer(self) self.tx_tick.timeout.connect(__tick_tx) self.tx_tick.start(1000) self.qmap_tick = qtcore4.QTimer(self) self.qmap_tick.timeout.connect(__tick_qmap) self.qmap_tick.start(250) ''' samps = [] limit = int(start_sps) for x in xrange(0, limit): a = abs(math.sin((float(x) / float(start_sps)) * 1000.0 * math.pi * 2.0)) theta = (float(x) / float(start_sps)) * 5000.0 * math.pi * 2.0 samps.append(cmath.rect(a, theta)) self.rx_noise = analog.fastnoise_source_c(analog.GR_GAUSSIAN, 0.7) self.rx_add = blocks.add_cc() self.rx_vsrc = blocks.vector_source_c(samps, True) #self.rx_file = blocks.file_sink(8, '/home/kmcguire/dump.base') self.rx = blocks.throttle(8, start_sps) #self.tb.connect(self.rx, self.rx_file) self.tb.connect(self.rx_vsrc, (self.rx_add, 0)) self.tb.connect(self.rx_noise, (self.rx_add, 1)) self.tb.connect(self.rx_add, self.rx) ''' self.middle.set_src_blk(self.rx) self.middle.change(512, 64) self.tb.start() self.vchannels = [] self.b = audio.sink(16000, '', True) self.audio_sink_base = audio.sink(16000) self.audio_sink = LimiterMultiplexer(tb=self.tb, dtype=numpy.float32, dtsize=4, maxinputs=8) self.tb.connect(self.audio_sink, self.audio_sink_base) self.tb.connect( self.audio_sink, debug.Debug(xtype=numpy.dtype(numpy.float32), tag='FROM RX LAST BLOCK')) self.audio_source = audio.source(16000) #self.audio_source = blocks.file_source(4, '/home/kmcguire/') ''' Configure the channels. ''' xself = self self.tb.lock() for x in xrange(0, chan_count): self.q_map.set_chan_volume(x, 0.5) self.q_map.set_chan_active(x, False) self.q_map.set_chan_volume(x, 0.8) self.q_map.set_chan_audio_level(x, 0.0) def __change_volume(self, volume): print 'set volume %s on channel %s' % (volume, self.ndx) xself.q_map.set_chan_volume(self.ndx, volume) def __change_squelch(self, squelch): xself.q_map.set_chan_squelch(self.ndx, squelch) def __change_active(self, active): self.active = active xself.q_map.set_chan_active(self.ndx, active) def __change_center_freq(self, center_freq): xself.qfft.set_center_freq(self.ndx, center_freq) xself.qfft.set_center_active(self.ndx, self.active) def __change_width(self, width_hz): xself.qfft.set_center_width(self.ndx, width_hz) def __set_audio_strength_query_func(self, f): xself.q_map.set_audio_strength_query_func(self.ndx, f) chanover = ChanOverProxy() chanover.ndx = x chanover.active = False chanover.change_volume = types.MethodType(__change_volume, chanover) chanover.change_squelch = types.MethodType(__change_squelch, chanover) chanover.change_active = types.MethodType(__change_active, chanover) chanover.change_center_freq = types.MethodType( __change_center_freq, chanover) chanover.change_width = types.MethodType(__change_width, chanover) chanover.set_audio_strength_query_func = types.MethodType( __set_audio_strength_query_func, chanover) block = mode_am.AM(self.tb, self.rx, self.tx, self.audio_sink, self.audio_source, chanover, self.beep) # The `start_sps` is needed as the control can not be accurately read # until later even though it has been set with this value. block.update(self.q_rx_cfreq.get_value(), self.q_tx_cfreq.get_value(), float(start_sps), float(start_sps)) self.vchannels.append(block) self.tb.unlock() def _mode_change(index): modes = { 'FM': mode_fm, 'AM': mode_am, } mode = self.mode_select.currentText() self.vchannels[self.cur_chan].deinit() self.vchannels[self.cur_chan].get_left().setParent(None) self.vchannels[self.cur_chan].get_right().setParent(None) print 'mode="%s"' % mode self.vchannels[self.cur_chan] = modes[mode]() chan = self.vchannels[self.cur_chan] left = chan.get_left() right = chan.get_right() left.setParent(self.left_bottom) right.setParent(self.right_bottom) left.move(0, 0) right.move(0, 0) self.mode_select.currentIndexChanged.connect(_mode_change) for chan in self.vchannels: left = chan.get_left() right = chan.get_right() left.setParent(self.left_bottom) right.setParent(self.right_bottom) left.move(0, 0) right.move(0, 0) left.resize(100, self.left_bottom.height()) left.hide() right.hide() beep = [] for x in xrange(0, 4000): theta = float(x) / 16000.0 * (1000.0 + float(x) * 0.20) * math.pi * 2.0 beep.append(math.sin(theta)) # A custom block may be well in this situation. Capable # of doing a one shot operation. self.uibeeper = OneShot(numpy.float32, numpy.array(beep)) self.audio_sink.connect(self.uibeeper) self.cur_chan = 0 self.set_cur_vchan(0)