[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Commit-gnuradio] r6347 - in grc/trunk: notes src src/Graphics src/Signa
|
From: |
jblum |
|
Subject: |
[Commit-gnuradio] r6347 - in grc/trunk: notes src src/Graphics src/SignalBlockDefs |
|
Date: |
Fri, 7 Sep 2007 01:44:09 -0600 (MDT) |
Author: jblum
Date: 2007-09-07 01:44:08 -0600 (Fri, 07 Sep 2007)
New Revision: 6347
Modified:
grc/trunk/notes/notes.txt
grc/trunk/src/ActionHandler.py
grc/trunk/src/ExecFlowGraph.py
grc/trunk/src/Graphics/MainWindow.py
grc/trunk/src/SignalBlockDefs/Filters.py
grc/trunk/src/SignalBlockDefs/Packet.py
grc/trunk/src/SignalBlockDefs/SignalBlockTree.py
Log:
removed old packet mods, file descriptor for tuntap, moved page access methods
into page class, fixed window resize bug
Modified: grc/trunk/notes/notes.txt
===================================================================
--- grc/trunk/notes/notes.txt 2007-09-06 19:53:33 UTC (rev 6346)
+++ grc/trunk/notes/notes.txt 2007-09-07 07:44:08 UTC (rev 6347)
@@ -1,9 +1,7 @@
############ Blocks to Add: ####################
-ofdm
--usrp misc settings
+-usrp misc settings?
-usrp quad souce, set z == 1 to ignore Q inputs
--blks blocks, add filesave for logging
--combine add/mult with add/mult vector
-multi-channel scope
############ Known Problems: ####################
@@ -12,6 +10,7 @@
-usrp transmit dies in lock/unlock
-packet blocks freeze in lock/unlock
-packet: remove flush when freezes fixed
+-audio dies lock/unlock
############ Features to Add: ####################
-startup tips
Modified: grc/trunk/src/ActionHandler.py
===================================================================
--- grc/trunk/src/ActionHandler.py 2007-09-06 19:53:33 UTC (rev 6346)
+++ grc/trunk/src/ActionHandler.py 2007-09-07 07:44:08 UTC (rev 6347)
@@ -52,6 +52,7 @@
self.main_window = Graphics.MainWindow(self.handle_states)
Preferences.load(self.main_window)
self.get_flow_graph = self.main_window.get_flow_graph
+ self.get_page = self.main_window.get_page
Messages.register_messenger(self.main_window.add_report_line)
Messages.register_messenger(sys.stdout.write)
Messages.send_init()
@@ -162,7 +163,7 @@
if not self.init_file_paths and
Preferences.restore_files(): self.init_file_paths = Preferences.files_open()
if not self.init_file_paths: self.init_file_paths = ['']
for file_path in self.init_file_paths:
self.main_window.new_page(file_path) #load pages from file paths
- if not self.main_window.get_page():
self.main_window.new_page() #ensure that at least a blank page exists
+ if not self.get_page(): self.main_window.new_page()
#ensure that at least a blank page exists
elif state == APPLICATION_QUIT:
if self.main_window.close_pages():
Preferences.save(self.main_window)
@@ -186,41 +187,41 @@
# Move/Rotate/Delete/Create
##############################################################################################
elif state == SIGNAL_BLOCK_MOVE:
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
elif state == SIGNAL_BLOCK_ROTATE_LEFT:
if self.get_flow_graph().rotate_selected(DIR_LEFT):
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
elif state == SIGNAL_BLOCK_ROTATE_RIGHT:
if self.get_flow_graph().rotate_selected(DIR_RIGHT):
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
elif state == ELEMENT_DELETE:
if self.get_flow_graph().delete_selected():
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
self.handle_states(NOTHING_SELECT)
- self.main_window.set_saved(False)
+ self.get_page().set_saved(False)
elif state == CONNECTION_CREATE or state ==
SIGNAL_BLOCK_CREATE:
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
self.handle_states(NOTHING_SELECT)
- self.main_window.set_saved(False)
+ self.get_page().set_saved(False)
elif state == SIGNAL_BLOCK_INC_TYPE:
if
self.get_flow_graph().type_controller_modify_selected(1):
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
elif state == SIGNAL_BLOCK_DEC_TYPE:
if
self.get_flow_graph().type_controller_modify_selected(-1):
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
elif state == SOCKET_CONTROLLER_INC:
if
self.get_flow_graph().socket_controller_modify_selected(1):
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
elif state == SOCKET_CONTROLLER_DEC:
if
self.get_flow_graph().socket_controller_modify_selected(-1):
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
##############################################################################################
# Window stuff
##############################################################################################
@@ -238,66 +239,66 @@
elif state == MATH_EXPR_WINDOW_DISPLAY:
Graphics.MathExprDialog()
elif state == FLOW_GRAPH_WINDOW_RESIZE:
- dimensions =
Graphics.FlowGraphWindowSizeDialog(self.main_window.get_size_request()).run()
- if dimensions != None:
-
self.main_window.set_size_request(dimensions[0], dimensions[1])
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+ dimensions =
Graphics.FlowGraphWindowSizeDialog(self.get_flow_graph().get_size_request()).run()
+ if dimensions:
+
self.get_flow_graph().set_size_request(*dimensions)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
##############################################################################################
# Variable and Param Modifications
##############################################################################################
elif state == SIGNAL_BLOCK_PARAM_MODIFY:
if self.get_flow_graph().param_modify_selected():
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
elif state == VARIABLE_MODIFY:
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
self.get_flow_graph().update()
elif state == VARIABLE_REORDER:
-
self.main_window.get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
- self.main_window.set_saved(False)
+
self.get_page().get_state_cache().save_new_state(self.get_flow_graph().to_nested_data())
+ self.get_page().set_saved(False)
##############################################################################################
# Undo/Redo
##############################################################################################
elif state == FLOW_GRAPH_UNDO:
- nested_data =
self.main_window.get_state_cache().get_prev_state()
+ nested_data =
self.get_page().get_state_cache().get_prev_state()
if nested_data != None:
self.handle_states(NOTHING_SELECT)
self.get_flow_graph().from_nested_data(nested_data)
- self.main_window.set_saved(False)
+ self.get_page().set_saved(False)
elif state == FLOW_GRAPH_REDO:
- nested_data =
self.main_window.get_state_cache().get_next_state()
+ nested_data =
self.get_page().get_state_cache().get_next_state()
if nested_data != None:
self.handle_states(NOTHING_SELECT)
self.get_flow_graph().from_nested_data(nested_data)
- self.main_window.set_saved(False)
+ self.get_page().set_saved(False)
##############################################################################################
- # New/Open/Save
+ # New/Open/Save/Close
##############################################################################################
elif state == FLOW_GRAPH_NEW:
self.main_window.new_page()
elif state == FLOW_GRAPH_OPEN:
- file_path =
Graphics.OpenFlowGraphFileDialog(self.get_flow_graph() and
self.main_window.get_file_path() or '').run()
+ file_path =
Graphics.OpenFlowGraphFileDialog(self.get_flow_graph() and
self.get_page().get_file_path() or '').run()
if file_path != None:
self.main_window.new_page(file_path)
elif state == FLOW_GRAPH_CLOSE:
self.main_window.close_page()
elif state == FLOW_GRAPH_SAVE:
- if not self.main_window.get_file_path():
self.handle_states(FLOW_GRAPH_SAVE_AS)
+ if not self.get_page().get_file_path():
self.handle_states(FLOW_GRAPH_SAVE_AS)
else:
try:
-
ParseXML.to_file(ParseXML.to_xml(self.get_flow_graph().to_nested_data()),
self.main_window.get_file_path())
- self.main_window.set_saved(True)
+
ParseXML.to_file(ParseXML.to_xml(self.get_flow_graph().to_nested_data()),
self.get_page().get_file_path())
+ self.get_page().set_saved(True)
except IOError:
-
Messages.send_fail_save(self.main_window.get_file_path())
- self.main_window.set_saved(False)
+
Messages.send_fail_save(self.get_page().get_file_path())
+ self.get_page().set_saved(False)
elif state == FLOW_GRAPH_SAVE_AS:
- file_path =
Graphics.SaveFlowGraphFileDialog(self.main_window.get_file_path()).run()
+ file_path =
Graphics.SaveFlowGraphFileDialog(self.get_page().get_file_path()).run()
if file_path != None:
- self.main_window.set_file_path(file_path)
+ self.get_page().set_file_path(file_path)
self.handle_states(FLOW_GRAPH_SAVE)
elif state == FLOW_GRAPH_SCREEN_CAPTURE:
- file_path =
Graphics.SaveImageFileDialog(self.main_window.get_file_path()).run()
+ file_path =
Graphics.SaveImageFileDialog(self.get_page().get_file_path()).run()
if file_path != None:
pixmap = self.get_flow_graph().pixmap
width, height = pixmap.get_size()
@@ -308,16 +309,16 @@
# Run/Stop
##############################################################################################
elif state == FLOW_GRAPH_EXEC:
- if not self.main_window.get_pid_file():
- if not self.main_window.get_saved() or not
self.main_window.get_file_path():
+ if not self.get_page().get_pid_file():
+ if not self.get_page().get_saved() or not
self.get_page().get_file_path():
self.handle_states(FLOW_GRAPH_SAVE)
#only save if file path missing or not saved
- if self.main_window.get_saved() and
self.main_window.get_file_path():
+ if self.get_page().get_saved() and
self.get_page().get_file_path():
ExecFlowGraphThread(self) #only
exec if file path and saved
elif state == FLOW_GRAPH_STOP:
MUTEX.lock()
- if self.main_window.get_pid_file():
- try:
os.kill(int(open(self.main_window.get_pid_file(), 'r').read()), 9)
- except: print "could not kill pid file:
%s"%self.main_window.get_pid_file()
+ if self.get_page().get_pid_file():
+ try:
os.kill(int(open(self.get_page().get_pid_file(), 'r').read()), 9)
+ except: print "could not kill pid file:
%s"%self.get_page().get_pid_file()
MUTEX.unlock()
elif state == '': #pass and run the global actions
pass
@@ -327,11 +328,11 @@
##############################################################################################
#set the exec button if the flow graph is valid and is not
already running
MUTEX.lock()
-
get_action_from_name(FLOW_GRAPH_EXEC).set_sensitive(self.get_flow_graph().is_valid()
and not self.main_window.get_pid_file())
-
get_action_from_name(FLOW_GRAPH_STOP).set_sensitive(self.main_window.get_pid_file()
!= '')
+
get_action_from_name(FLOW_GRAPH_EXEC).set_sensitive(self.get_flow_graph().is_valid()
and not self.get_page().get_pid_file())
+
get_action_from_name(FLOW_GRAPH_STOP).set_sensitive(self.get_page().get_pid_file()
!= '')
MUTEX.unlock()
#saved status
- get_action_from_name(FLOW_GRAPH_SAVE).set_sensitive(not
self.main_window.get_saved())
+ get_action_from_name(FLOW_GRAPH_SAVE).set_sensitive(not
self.get_page().get_saved())
self.main_window.set_title()
Preferences.show_reports_window(self.main_window)
@@ -345,19 +346,18 @@
Thread.__init__(self)
self.handle_states = action_handler.handle_states
self.flow_graph = action_handler.get_flow_graph()
- self.main_window = action_handler.main_window
+ #store page and dont use main window calls in run
+ self.page = action_handler.get_page()
#random id so multiple flow graphs can run w/o files
intersecting
rand_id = random.randint(10000, 99999)
- #store page and dont use main window calls in run
- self.page = self.main_window.get_page()
#set files
- self.file_path = self.main_window.get_file_path()
+ self.file_path = self.page.get_file_path()
self.report_file = '/tmp/grc-%d-%d.report'%(os.getpid(),
rand_id)
self.pid_file = '/tmp/grc-%d-%d.pid'%(os.getpid(), rand_id)
- self.main_window.set_pid_file(self.pid_file)
+ self.page.set_pid_file(self.pid_file)
get_action_from_name(FLOW_GRAPH_EXEC).set_sensitive(False)
get_action_from_name(FLOW_GRAPH_STOP).set_sensitive(True)
- Messages.send_start_exec(self.main_window.get_file_path())
+ Messages.send_start_exec(self.page.get_file_path())
self.start()
def run(self):
@@ -379,7 +379,7 @@
try: os.remove(self.pid_file)
except: print "could not remove pid file: %s"%self.pid_file
MUTEX.lock()
- self.page.pid_file = ''
+ self.page.set_pid_file('')
MUTEX.unlock()
self.handle_states()
Modified: grc/trunk/src/ExecFlowGraph.py
===================================================================
--- grc/trunk/src/ExecFlowGraph.py 2007-09-06 19:53:33 UTC (rev 6346)
+++ grc/trunk/src/ExecFlowGraph.py 2007-09-07 07:44:08 UTC (rev 6347)
@@ -111,7 +111,7 @@
"""For each call back, parse all of the data and
call the registered callback function on that data."""
#MUTEX.lock()
- print "***\n\nCallback Time BEGIN\n\n***"
+ #print "***\n\nCallback Time BEGIN\n\n***"
if self.started:
if self.callbacks: #parse regular callbacks
for function, data_type_params in
self.callbacks:
@@ -121,7 +121,7 @@
for function, data_type_params in
self.callbacks_locked + self.callbacks_cond:
self._parse_callback(function,
*data_type_params)
self.unlock()
- print "***\n\nCallback Time END\n\n***"
+ #print "***\n\nCallback Time END\n\n***"
#MUTEX.unlock()
def _parse_nested_data(self, nested_data):
Modified: grc/trunk/src/Graphics/MainWindow.py
===================================================================
--- grc/trunk/src/Graphics/MainWindow.py 2007-09-06 19:53:33 UTC (rev
6346)
+++ grc/trunk/src/Graphics/MainWindow.py 2007-09-07 07:44:08 UTC (rev
6347)
@@ -43,17 +43,23 @@
class Page(gtk.HBox):
"""A page in the notebook."""
- def __init__(self, main_window):
+ def __init__(self, main_window, file_path=''):
"""
Page constructor.
@param main_window main window
+ @param file_path path to a flow graph file
"""
+ #import the file
self.main_window = main_window
+ initial_state = ParseXML.from_xml(ParseXML.from_file(file_path
or INITIAL_FLOW_GRAPH_FILE))
+
self.main_window.get_flow_graph().from_nested_data(initial_state)
+ self.state_cache = StateCache(initial_state)
+ self.set_pid_file('')
+ self.set_file_path(file_path)
+ self.set_saved(True)
+ #import success, initialize page
gtk.HBox.__init__(self, False, 0)
- self.show()
- self.pid_file = ''
- self.file_path = ''
- self.saved = True
+ self.show()
#tab box to hold label and close button
self.tab = gtk.HBox(False, 0)
#setup tab label
@@ -99,6 +105,56 @@
"""
return self.tab
+ def get_pid_file(self):
+ """!
+ Get the pid file for the flow graph.
+ @return the pid file or ''
+ """
+ return self.pid_file
+
+ def set_pid_file(self, pid_file=''):
+ """!
+ Set the pid file, '' for no pid file.
+ @param pid_file file path string
+ """
+ self.pid_file = pid_file
+
+ def get_file_path(self):
+ """!
+ Get the file path for the flow graph.
+ @return the file path or ''
+ """
+ return self.file_path
+
+ def set_file_path(self, file_path=''):
+ """!
+ Set the file path, '' for no file path.
+ @param file_path file path string
+ """
+ if file_path: self.file_path = os.path.abspath(file_path)
+ else: self.file_path = ''
+
+ def get_saved(self):
+ """!
+ Get the saved status for the flow graph.
+ @return true if saved
+ """
+ return self.saved
+
+ def set_saved(self, saved=True):
+ """!
+ Set the saved status.
+ @param saved boolean status
+ """
+ self.saved = saved
+
+ def get_state_cache(self):
+ """!
+ Get the state cache for the flow graph.
+ @return the state cache
+ """
+ return self.state_cache
+
############################################################
## Main window
############################################################
@@ -188,8 +244,8 @@
title = ''.join((
MAIN_WINDOW_PREFIX,
' - Editing: ',
- (self.get_file_path() or
NEW_FLOGRAPH_TITLE),
- (self.get_saved() and ' ' or '*'),
#blank must be non empty
+ (self.get_page().get_file_path() or
NEW_FLOGRAPH_TITLE),
+ (self.get_page().get_saved() and ' ' or
'*'), #blank must be non empty
)
)
else: title = MAIN_WINDOW_PREFIX + ' - Editor '
@@ -222,7 +278,7 @@
Get the file names for all the pages, in order.
@return list of file paths
"""
- return [self.notebook.get_nth_page(page_num).file_path for
page_num in range(self.notebook.get_n_pages())]
+ return [self.notebook.get_nth_page(page_num).get_file_path()
for page_num in range(self.notebook.get_n_pages())]
def new_page(self, file_path=''):
"""!
@@ -233,23 +289,14 @@
if file_path and file_path in self._get_files(): #already open
page =
self.notebook.get_nth_page(self._get_files().index(file_path))
self.set_page(page)
- return
- page = Page(self)
- page.file_path = file_path
- if page.file_path:
- try: #try to load from file
- Messages.send_start_load(page.file_path)
- initial_state =
ParseXML.from_xml(ParseXML.from_file(page.file_path))
-
self.get_flow_graph().from_nested_data(initial_state)
- page.state_cache = StateCache(initial_state)
- Messages.send_end_load()
- except Exception, e:
- Messages.send_fail_load(e)
- return
- else: #load the default file
- initial_state =
ParseXML.from_xml(ParseXML.from_file(INITIAL_FLOW_GRAPH_FILE))
- self.get_flow_graph().from_nested_data(initial_state)
- page.state_cache = StateCache(initial_state)
+ return
+ try: #try to load from file
+ if file_path: Messages.send_start_load(file_path)
+ page = Page(self, file_path)
+ if file_path: Messages.send_end_load()
+ except Exception, e:
+ Messages.send_fail_load(e)
+ return
self.notebook.append_page(page, page.get_tab())
self.set_page(page)
@@ -263,7 +310,7 @@
@param page_num new page number
"""
self.current_page = self.notebook.get_nth_page(page_num)
- state = self.get_state_cache().get_current_state()
+ state = self.get_page().get_state_cache().get_current_state()
self.get_flow_graph().from_nested_data(state)
self.handle_states(NOTHING_SELECT)
@@ -321,11 +368,7 @@
"""
self.current_page = page
self.notebook.set_current_page(self.notebook.page_num(self.current_page))
-
- ############################################################
- ## Access flow graph variables
- ############################################################
-
+
def get_flow_graph(self):
"""
Get the flow graph in this main window.
@@ -333,53 +376,6 @@
"""
return self.flow_graph
- def get_pid_file(self):
- """!
- Get the pid file for the flow graph.
- @return the pid file or ''
- """
- return self.get_page().pid_file
-
- def set_pid_file(self, pid_file=''):
- """!
- Set the pid file, '' for no pid file.
- @param pid_file file path string
- """
- self.get_page().pid_file = pid_file
-
- def get_file_path(self):
- """!
- Get the file path for the flow graph.
- @return the file path or ''
- """
- return self.get_page().file_path
-
- def set_file_path(self, file_path=''):
- """!
- Set the file path, '' for no file path.
- @param file_path file path string
- """
- self.get_page().file_path = os.path.abspath(file_path)
-
- def get_saved(self):
- """!
- Get the saved status for the flow graph.
- @return true if saved
- """
- return self.get_page().saved
-
- def set_saved(self, saved=True):
- """!
- Set the saved status.
- @param saved boolean status
- """
- self.get_page().saved = saved
-
- def get_state_cache(self):
- """!
- Get the state cache for the flow graph.
- @return the state cache
- """
- return self.get_page().state_cache
+
\ No newline at end of file
Modified: grc/trunk/src/SignalBlockDefs/Filters.py
===================================================================
--- grc/trunk/src/SignalBlockDefs/Filters.py 2007-09-06 19:53:33 UTC (rev
6346)
+++ grc/trunk/src/SignalBlockDefs/Filters.py 2007-09-07 07:44:08 UTC (rev
6347)
@@ -142,13 +142,23 @@
fcn = blks2.channel_model
sb.add_input_socket('in', Complex())
sb.add_output_socket('out', Complex())
- sb.add_param('Noise Voltage', Float(0.0))
- sb.add_param('Freq Offset', Float(0.0))
+ sb.add_param('Noise Voltage', Float(0.0), variable=True)
+ sb.add_param('Freq Offset', Float(0.0), variable=True)
sb.add_param('Epsilon', Float(1.0))
- sb.add_param('Taps', ComplexVector('1.0,0.0'))
- sb.set_docs('''Simulate channel distortion.''')
+ sb.add_param('Taps', ComplexVector('1.0,0.0'), variable=True)
+ sb.set_docs('''\
+Creates a channel model that includes:
+ - AWGN noise power in terms of noise voltage
+ - A frequency offest in the channel in ratio
+ - A timing offset ratio to model clock difference (epsilon)
+ - Multipath taps
+''')
def make(fg, noise_voltage, frequency_offset, epsilon, taps):
- return fcn(noise_voltage.parse(), frequency_offset.parse(),
epsilon.parse(), taps.parse())
+ block = fcn(noise_voltage.parse(), frequency_offset.parse(),
epsilon.parse(), taps.parse())
+ fg.add_callback(block.set_noise_voltage, noise_voltage)
+ fg.add_callback(block.set_frequency_offset, frequency_offset)
+ fg.add_callback(block.set_taps, taps)
+ return block
return sb, make
###########################################################################
Modified: grc/trunk/src/SignalBlockDefs/Packet.py
===================================================================
--- grc/trunk/src/SignalBlockDefs/Packet.py 2007-09-06 19:53:33 UTC (rev
6346)
+++ grc/trunk/src/SignalBlockDefs/Packet.py 2007-09-07 07:44:08 UTC (rev
6347)
@@ -22,209 +22,14 @@
import struct
import os
-import gnuradio.gr.gr_threading as threading
from DataTypes import *
-from gnuradio import gr,blks,packet_utils
-from SignalBlockConstants import all_choices,DEFAULT_QUEUE_LIMIT
+from gnuradio import gr
+from SignalBlockConstants import all_choices
-MAX_ACCESS_CODE_LENGTH = 64
-MAX_PACKET_LENGTH = len(packet_utils.random_mask_tuple)#4096
-DEFAULT_PACKET_LENGTH = 512
-
#######################################################################################
-## Packet Modulator and Demodulator Hier Block
+## TUN/TAP
#######################################################################################
-class PacketModThread(threading.Thread):
- """
- Thread to forward data between the message queue and the packet
modulator.
- Read messages from the message queue, slice them up to the packet
length,
- and pass them to the send packet function.
- """
- def __init__(self, msgq, send_packet, packet_length):
- """!
- PacketModThread contructor.
- @param msgq the message queue with incoming data
- @param send_packet a function of one argument to send a packet
- """
- self.msgq = msgq
- self.send_packet = send_packet
- self.packet_length = packet_length
- threading.Thread.__init__(self)
- self.setDaemon(1)
- self.keep_running = True
- self.start()
- print 'Created packet modulator thread.'
-
- def run(self):
- """In an endless while loop: read the msgq and call send
packet."""
- r = '' #residual message
- while self.keep_running:
- msg = self.msgq.delete_head() # blocking read of
message queue
- sr = r + msg.to_string()
- num_packets = len(sr)/int(self.packet_length) #integer
arithmetic
- r_index = self.packet_length*num_packets
- s = sr[0:r_index] #portion of message divisible
by packet size
- r = sr[r_index:] #residual portion of message
smaller then packet size
- #print len(s), len(r), msg.type(), msg.arg1(),
msg.arg2()
- for i in range(num_packets):
self.send_packet(s[i*self.packet_length:(i+1)*self.packet_length])
-
-class PacketModHelper(gr.hier_block2):
- """Forward data from the gr data stream to the mod packet."""
- def __init__(self, item_size, packet_length, samples_per_symbol,
bits_per_symbol, access_code, pad_for_usrp):
- """!
- PacketModHelper constructor.
- @param item_size the size in bytes of the input data stream
- @param packet_length the length in bytes of the packets
- @param *args the arguments for blks.mod_pkts
- """
- #create hier block
- gr.hier_block2.__init__(
- self, 'packet_mod',
- gr.io_signature(1, 1, item_size),
- gr.io_signature(1, 1, Byte().get_num_bytes())
- )
- #dummy modulator with access functions
- modulator = gr.skiphead(Byte().get_num_bytes(), 0)
- modulator.samples_per_symbol = lambda: samples_per_symbol
- modulator.bits_per_symbol = lambda: bits_per_symbol
- #create the packet modulator (handles the output data stream)
- self.packet_mod = blks.mod_pkts(
- fg=self,
- modulator=modulator,
- access_code=access_code,
- msgq_limit=DEFAULT_QUEUE_LIMIT,
- pad_for_usrp=pad_for_usrp,
- )
- #the message sink (handles the input data stream)
- self.msgq = gr.msg_queue(DEFAULT_QUEUE_LIMIT)
- msg_sink = gr.message_sink(item_size, self.msgq, False)
- #connections
- self.connect(self.packet_mod.tail, self)
- self.connect(self, msg_sink)
- #create/start the thread
- PacketModThread(self.msgq, self.packet_mod.send_pkt,
packet_length)
-
-class PacketDemodHelper(gr.hier_block2):
- """Forward data from demod packet to the gr data stream."""
- def __init__(self, item_size, access_code, threshold):
- """!
- PacketDemodHelper constructor.
- @param item_size the size in bytes of the output data stream
- @param *args the arguments for blks.demod_pkts
- @param msgq_limit the queue limit for the message source
- """
- #create hier block
- gr.hier_block2.__init__(
- self, 'packet_demod',
- gr.io_signature(1, 1, Byte().get_num_bytes()),
- gr.io_signature(1, 1, item_size)
- )
- #the message source (handles the output data stream)
- msg_source = gr.message_source(item_size, DEFAULT_QUEUE_LIMIT)
- msgq = msg_source.msgq()
- def callback(ok, payload):
- if ok: msgq.insert_tail(gr.message_from_string(payload,
0, item_size, len(payload)/item_size))
- #dummy demodulator
- demodulator = gr.skiphead(Byte().get_num_bytes(), 0)
- #create the packet demodulator (handles the input data stream)
- packet_demod = blks.demod_pkts(
- fg=self,
- demodulator=demodulator,
- access_code=access_code,
- callback=callback,
- threshold=threshold,
- )
- #connections
- self.connect(msg_source, self)
- self.connect(self, packet_demod.head)
-
-#######################################################################################
-## Packet Modulator and Demodulator Defs
-#######################################################################################
-
-def PacketMod(sb):
- blks.mod_pkts, gr.throttle, gr.message_sink #uses
- type = Enum(all_choices, 1)
- sb.add_input_socket('in', Variable(type)) #packet input
- sb.add_output_socket('out', Byte())
- sb.add_param('Type', type, False, type=True)
- sb.add_param('Modulator Type', Enum([
- ('GMSK', blks.gmsk_mod),
- ('DBPSK', blks.dbpsk_mod),
- ('DQPSK', blks.dqpsk_mod),
- ('D8PSK', blks.d8psk_mod),
- ('QAM 8', blks.qam8_mod),
- ('QAM 64', blks.qam64_mod),
- ('QAM 256', blks.qam256_mod),
- ]))
- sb.add_param('Samples/Symbol', Int(2, min=2))
- sb.add_param('Packet Length', Int(DEFAULT_PACKET_LENGTH, min=1,
max=MAX_PACKET_LENGTH))
- sb.add_param('Access Code', String('', max=MAX_ACCESS_CODE_LENGTH))
- sb.add_param('Pad for USRP', Bool(true='Yes', false='No', default=True))
- sb.set_docs('''\
-The packet modulator wraps a data stream into packets.
----
-Modulator type: tells the packet modulator how many bits per symbol to use. \
-A modulator block should still be connected to the output of this block.
-
-Packet length: length of a packet in bytes, must be a multiple of the size of
the input data stream, and no greater than %d.
-
-Access code/sync vector: string of 1's and 0's between 1 and %d long. Leave
blank for default.
-
-Pad for USRP: If true, packets are padded such that they end up a multiple of
128 samples.
-
-Use whitener offset: If true, start of whitener XOR string is incremented each
packet.
-'''%(MAX_PACKET_LENGTH, MAX_ACCESS_CODE_LENGTH))
- def make(fg, type, mod_type, samples_per_symbol, packet_length,
access_code, pad_for_usrp):
- access_code = access_code.parse()
- if access_code == '': access_code = None #access code
should be None if blank
- item_size = type.parse().get_num_bytes()
- packet_length = packet_length.parse()
- if packet_length%item_size != 0: #verify that packet
length is a multiple of the stream size
- raise ValueError('The packet length: "%d" is not a
mutiple of the stream size: "%d".'%(packet_length, item_size))
- block = PacketModHelper(
- item_size=item_size,
- packet_length=packet_length,
- samples_per_symbol=samples_per_symbol.parse(),
- bits_per_symbol=mod_type.parse().bits_per_symbol(),
- access_code=access_code,
- pad_for_usrp=pad_for_usrp.parse(),
- ) #build packet modulator
- return block
- return sb, make
-
-def PacketDemod(sb):
- blks.demod_pkts, gr.throttle, gr.message_source #uses
- type = Enum(all_choices, 1)
- sb.add_output_socket('out', Variable(type)) #packet output
- sb.add_input_socket('in', Byte())
- sb.add_param('Type', type, False, type=True)
- sb.add_param('Access Code', String('', max=MAX_ACCESS_CODE_LENGTH))
- sb.add_param('Threshold', Int(-1))
- sb.set_docs('''\
-The packet demodulator unwraps packets from a data stream.
----
-Access code/sync vector: string of 1's and 0's between 1 and %d long. Leave
blank for default.
-
-Threshold: detect access_code with up to threshold bits wrong.
-
-Queue limit: maximum number of messages in message queue.
-'''%MAX_ACCESS_CODE_LENGTH)
- def make(fg, type, access_code, threshold):
- access_code = access_code.parse()
- if access_code == '': access_code = None #access code
should be None if blank
- return PacketDemodHelper(
- item_size=type.parse().get_num_bytes(),
- access_code=access_code,
- threshold=threshold.parse(),
- ) #build packet demodulator
- return sb, make
-
-#######################################################################################
-## TUN/TAP Access Threads
-#######################################################################################
-
IFF_TUN = 0x0001 # tunnel IP packets
IFF_TAP = 0x0002 # tunnel ethernet frames
IFF_NO_PI = 0x1000 # don't pass extra packet info
@@ -250,13 +55,12 @@
return tun_fd, ifname
class TunTapHelper(gr.hier_block2):
- """Make the tun tap hier2 block and start threads."""
- def __init__(self, item_size, tun_fd, ifname):
+ """Make the tun tap hier2 block."""
+ def __init__(self, item_size, tun_fd):
"""!
TunTapHelper constructor.
@param item_size the size in bytes of the IO data stream
@param tun_fd the file descriptor for the virtual device
- @param ifname the name of virtual interface
"""
#create hier block
gr.hier_block2.__init__(
@@ -264,80 +68,15 @@
gr.io_signature(1, 1, item_size),
gr.io_signature(1, 1, item_size)
)
- msg_source = gr.message_source(item_size, DEFAULT_QUEUE_LIMIT)
- msgq_source = msg_source.msgq()
- msgq_sink = gr.msg_queue(DEFAULT_QUEUE_LIMIT)
- msg_sink = gr.message_sink(item_size, msgq_sink, False)
- #start threads
- TunSinkThread(msgq_sink, tun_fd, ifname)
- TunSourceThread(msgq_source, item_size, tun_fd, ifname)
+ #I/O blocks
+ sink = gr.file_descriptor_sink(item_size, tun_fd)
+ source = gr.file_descriptor_source(item_size, tun_fd)
#connect
- self.connect(self, msg_sink)
- self.connect(msg_source, self)
+ self.connect(self, sink)
+ self.connect(source, self)
-class TunSinkThread(threading.Thread):
- """
- Thread to forward data from the message queue and to the virtual device.
- """
- def __init__(self, msgq, tun_fd, ifname):
- """!
- TunSinkThread contructor.
- @param msgq the message queue with incoming data
- @param tun_fd the file descriptor for the virtual device
- @param ifname the name of virtual interface
- """
- self.msgq = msgq
- self.tun_fd = tun_fd
- threading.Thread.__init__(self)
- self.setDaemon(1)
- self.keep_running = True
- self.start()
- print 'Created tun sink thread for device "%s".'%ifname
-
- def run(self):
- """In an endless while loop: read the msgq and write to tun."""
- while self.keep_running:
- msg = self.msgq.delete_head() # blocking read of
message queue
- os.write(self.tun_fd, msg.to_string())
-
-class TunSourceThread(threading.Thread):
- """
- Thread to forward data from the virtual device to the message queue.
- """
- def __init__(self, msgq, item_size, tun_fd, ifname):
- """!
- TunSourceThread contructor.
- @param msgq the message queue for outgoing data
- @param item_size the size of the stream in bytes
- @param tun_fd the file descriptor for the virtual device
- @param ifname the name of virtual interface
- """
- self.msgq = msgq
- self.item_size = item_size
- self.tun_fd = tun_fd
- threading.Thread.__init__(self)
- self.setDaemon(1)
- self.keep_running = True
- self.start()
- print 'Created tun source thread for device "%s".'%ifname
-
- def run(self):
- """In an endless while loop: read the msgq and write to tun."""
- r = ''
- while self.keep_running:
- sr = r + os.read(self.tun_fd, 128)
- num_items = len(sr)/self.item_size
- r_index = self.item_size*num_items
- s = sr[0:r_index] #portion of string divisible by
item size
- r = sr[r_index:] #residual portion of string
smaller then item size
- if s: self.msgq.insert_tail(gr.message_from_string(s,
self.item_size))
-
-#######################################################################################
-## TUN/TAP Block Defs
-#######################################################################################
-
def TunTap(sb):
- gr.message_sink #uses
+ gr.file_descriptor_sink, gr.file_descriptor_source #uses
type = Enum(all_choices, 1)
sb.add_input_socket('in', Variable(type))
sb.add_output_socket('out', Variable(type))
@@ -357,12 +96,11 @@
''')
def make(fg, type, tun, virt, ip_addr):
item_size = type.parse().get_num_bytes()
- msgq = gr.msg_queue(DEFAULT_QUEUE_LIMIT)
tun_fd, ifname = open_tun_interface(tun.parse(), virt.parse())
#try to set the ip address
ip_addr = ip_addr.parse()
if ip_addr: os.system('ifconfig %s %s'%(ifname, ip_addr))
- return TunTapHelper(item_size, tun_fd, ifname)
+ return TunTapHelper(item_size, tun_fd)
return sb, make
\ No newline at end of file
Modified: grc/trunk/src/SignalBlockDefs/SignalBlockTree.py
===================================================================
--- grc/trunk/src/SignalBlockDefs/SignalBlockTree.py 2007-09-06 19:53:33 UTC
(rev 6346)
+++ grc/trunk/src/SignalBlockDefs/SignalBlockTree.py 2007-09-07 07:44:08 UTC
(rev 6347)
@@ -158,8 +158,6 @@
('GMSK Demodulator', Modulators.GMSKDemod),
('QAM Modulator', Modulators.QAMMod),
('QAM Demodulator', Modulators.QAMDemod),
- ('Packet Modulator', Packet.PacketMod),
- ('Packet Demodulator', Packet.PacketDemod),
]),
('Coders', [
('Constellation Decoder',
Coders.ConstellationDecoder),
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Commit-gnuradio] r6347 - in grc/trunk: notes src src/Graphics src/SignalBlockDefs,
jblum <=