def __init__(
self,hop_interval,post_guard,pre_guard,tx_freq_list,rx_freq_list,lead_limit,link_bps
):
"""
Inputs: complex stream from USRP, pkt in, ctrl in
Outputs: pkt out, ctrl out
"""
gr.block.__init__(
self,
name = "fhss_engine",
in_sig = [numpy.complex64],
out_sig = None,
num_msg_inputs = 3,
num_msg_outputs = 3,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.hop_interval = hop_interval
self.post_guard = post_guard
self.pre_guard = pre_guard
self.lead_limit = lead_limit
self.link_bps = link_bps
self.tx_freq_list = map(float,tx_freq_list.split())
self.tx_freq_list_length = len(self.tx_freq_list)
self.rx_freq_list = map(float,tx_freq_list.split())
self.rx_freq_list_length = len(self.tx_freq_list)
self.hop_index = 0
self.bytes_per_slot = int( ( self.hop_interval - self.post_guard - self.pre_guard ) * self.link_bps / 8 )
self.queue = Queue.Queue() #queue for msg destined for ARQ path
self.tx_queue = Queue.Queue()
self.last_rx_time = 0
self.last_rx_rate = 0
self.samples_since_last_rx_time = 0
self.next_interval_start = 0
self.next_transmit_start = 0
self.know_time = False
self.found_time = False
self.found_rate = False
self.set_tag_propagation_policy(gr_extras.TPP_DONT)
self.has_old_msg = False
self.overhead = 20
self.pad_data = numpy.zeros( ( 1, 40),dtype='uint8')[0]
#print self.pad_data
self.tx_slots_passed = 0
self.rx_state = RX_SEARCH
self.plkt_received = False
self.tune_lead = 0.002
self.rx_hop_index = 0
self.consecutive_miss = 0
def __init__(
self,period,key,value
):
"""
The input is a pmt message blob.
Non-blob messages will be ignored.
The output is a byte stream for the modulator
@param period: Time between blopbs
@param key: String for key
@param value: String for value
"""
gr.block.__init__(
self,
name = "simple_mac",
in_sig = None,
out_sig = None,
has_msg_input = False,
num_msg_outputs = 1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.period = period
self.key = key
self.value = value
def __init__(
self,freq_list
):
"""
Two msg ports in, two msg ports out
"""
gr.block.__init__(
self,
name = "my_second_msg_block",
in_sig = None,
out_sig = None,
num_msg_inputs = 2,
num_msg_outputs = 2,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.freq_list = map(float,freq_list.split(','))
self.freq_list_len = len(self.freq_list)
print self.freq_list_len
self.index = 0
def __init__(
self,
):
"""
The input is a stream of bytes.
Outputs a blob with value of current byte if it is different from last.
"""
gr.block.__init__(
self,
name = "transition_detect",
in_sig = [numpy.uint8],
out_sig = None,
has_msg_input = False,
num_msg_outputs = 1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.old_result = 0;
self.key = pmt.pmt_string_to_symbol("example_key")
self.value = pmt.pmt_string_to_symbol("example_value")
self.trans_count = 0
def __init__(
self,key
):
"""
The input is a pmt message blob.
Non-blob messages will be ignored.
The output is pmt message blob
@param key: String replacement for key
"""
gr.block.__init__(
self,
name = "append_key",
in_sig = None,
out_sig = None,
has_msg_input = True,
num_msg_outputs = 1,
)
self.key = key
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
def __init__(self, period, key, value):
"""
The input is a pmt message blob.
Non-blob messages will be ignored.
The output is a byte stream for the modulator
@param period: Time between blopbs
@param key: String for key
@param value: String for value
"""
gr.block.__init__(
self,
name="simple_mac",
in_sig=None,
out_sig=None,
has_msg_input=False,
num_msg_outputs=1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.period = period
self.key = key
self.value = value
def __init__(
self,channel,arq
):
"""
Sets the key of a blob as neccassary for simple_mac and similar blocks.
Encodes information like destination radio addr, ARQ settings etc.
Blob in, blob out.
@param destination_addr: physical address of radio the pkt is destined for
@param ARQ: Use ARQ or don't
"""
gr.block.__init__(
self,
name = "virtual_channel_formatter",
in_sig = None,
out_sig = None,
num_msg_inputs = 1,
num_msg_outputs = 1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.channel = channel
self.arq = arq
def __init__(
self
):
"""
First input is a state.
Will hold state staticly until updated received on first input
Will queue messages from second input.
Will pass queued messages to output when state is '0'
"""
gr.block.__init__(
self,
name = "channel_access_controller",
in_sig = None,
out_sig = None,
num_msg_inputs = 2,
num_msg_outputs = 1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.q = Queue.Queue(maxsize=0)
self.channel_state = READY
def __init__(self, hop_interval, post_guard, pre_guard, tx_freq_list,
lead_limit, link_bps):
"""
Inputs: complex stream from USRP, pkt in, ctrl in
Outputs: pkt out, ctrl out
"""
gr.block.__init__(
self,
name="fhss_engine_tx",
in_sig=[numpy.complex64],
out_sig=None,
num_msg_inputs=3,
num_msg_outputs=3,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.hop_interval = hop_interval
self.post_guard = post_guard
self.pre_guard = pre_guard
self.lead_limit = lead_limit
self.link_bps = link_bps
self.tx_freq_list = map(float, tx_freq_list.split(','))
self.tx_freq_list_length = len(self.tx_freq_list)
self.hop_index = 0
self.bytes_per_slot = int(
(self.hop_interval - self.post_guard - self.pre_guard) *
self.link_bps / 8)
self.queue = Queue.Queue() #queue for msg destined for ARQ path
self.tx_queue = Queue.Queue()
self.last_rx_time = 0
self.last_rx_rate = 0
self.samples_since_last_rx_time = 0
self.next_interval_start = 0
self.next_transmit_start = 0
self.know_time = False
self.found_time = False
self.found_rate = False
self.set_tag_propagation_policy(gr_extras.TPP_DONT)
self.has_old_msg = False
self.overhead = 20
self.pad_data = numpy.zeros((1, 1500), dtype='uint8')[0]
#print self.pad_data
self.tx_slots_passed = 0
self.rx_state = RX_SEARCH
self.plkt_received = False
self.tune_lead = 0.003
self.rx_hop_index = 0
self.consecutive_miss = 0
def __init__(self, ber=0.01, bits_per_byte=1):
gr.block.__init__(self, name='bsc' ,in_sig = None,
out_sig = None, num_msg_inputs = 1,
num_msg_outputs = 1)
self.ber = ber
self.bits_per_byte = bits_per_byte
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
def __init__(self, msgq):
gr.block.__init__(self,
name="_queue_to_blob",
in_sig=None,
out_sig=None,
num_msg_outputs=1)
self._msgq = msgq
self._mgr = pmt.pmt_mgr()
for i in range(64):
self._mgr.set(pmt.pmt_make_blob(10000))
def __init__(self, msgq):
gr.block.__init__(
self, name = "_queue_to_blob",
in_sig = None, out_sig = None,
num_msg_outputs = 1
)
self._msgq = msgq
self._mgr = pmt.pmt_mgr()
for i in range(64):
self._mgr.set(pmt.pmt_make_blob(10000))
def __init__(self, device, parity, baudrate, stopbits, bytesize, wait_for_newline):
"""
Serial port w/ blobs in and out
"""
gr.block.__init__(self, name="serial_port", in_sig=None, out_sig=None, num_msg_inputs=1, num_msg_outputs=1)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.device = device
self.parity = parity
self.baudrate = baudrate
self.stopbits = stopbits
self.bytesize = bytesize
self.wait_for_newline = wait_for_newline
# set parity
if self.parity == NONE:
self.parity = serial.PARITY_NONE
elif self.parity == EVEN:
self.parity = serial.PARITY_EVEN
else:
self.parity = serial.PARITY_ODD
if self.stopbits == STOPBITS_ONE:
self.stopbits = serial.STOPBITS_ONE
elif self.stopbits == STOPBITS_TWO:
self.stopbits = serial.STOPBITS_TWO
if self.bytesize == WORD_SIZE_7:
self.bytesize = serial.SEVENBITS
else:
self.bytesize = serial.EIGHTBITS
# configure the serial connections (the parameters differs on the device you are connecting to)
self.ser = serial.Serial(
port=self.device, baudrate=self.baudrate, parity=self.parity, stopbits=self.stopbits, bytesize=self.bytesize
)
"""
self.ser = serial.Serial(
port=self.device,
baudrate=self.baudrate,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS
)
"""
print "Opened: ", self.ser.portstr # check which port was really used
self.ser.write("hel;lkfsdsa;lkfjdsaflo\n\r") # write a string
def __init__(self, initial_slot, slot_interval, guard_interval, num_slots,
lead_limit, link_bps):
"""
Inputs: complex stream from USRP, pkt in, ctrl in
Outputs: pkt out, ctrl out
"""
gr.block.__init__(
self,
name="tdma_engine",
in_sig=[numpy.complex64],
out_sig=None,
num_msg_inputs=3,
num_msg_outputs=2,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.initial_slot = initial_slot
self.slot_interval = slot_interval
self.guard_interval = guard_interval
self.num_slots = num_slots
self.lead_limit = lead_limit
self.link_bps = link_bps
self.bytes_per_slot = int(
(self.slot_interval - self.guard_interval) * self.link_bps / 8)
self.queue = Queue.Queue() #queue for msg destined for ARQ path
self.tx_queue = Queue.Queue()
self.last_rx_time = 0
self.last_rx_rate = 0
self.samples_since_last_rx_time = 0
self.next_interval_start = 0
self.next_transmit_start = 0
self.know_time = False
self.found_time = False
self.found_rate = False
self.set_tag_propagation_policy(extras_swig.TPP_DONT)
self.has_old_msg = False
self.overhead = 15
self.pad_data = numpy.fromstring(
'this idsaf;lkjkfdjsd;lfjs;lkajskljf;klajdsfk', dtype='uint8')
self.tx_slots_passed = 0
def __init__(
self,initial_slot,slot_interval,guard_interval,num_slots,lead_limit,link_bps
):
"""
Inputs: complex stream from USRP, pkt in, ctrl in
Outputs: pkt out, ctrl out
"""
gr.block.__init__(
self,
name = "tdma_engine",
in_sig = [numpy.complex64],
out_sig = None,
num_msg_inputs = 3,
num_msg_outputs = 2,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.initial_slot = initial_slot
self.slot_interval = slot_interval
self.guard_interval = guard_interval
self.num_slots = num_slots
self.lead_limit = lead_limit
self.link_bps = link_bps
self.bytes_per_slot = int( ( self.slot_interval - self.guard_interval ) * self.link_bps / 8 )
self.queue = Queue.Queue() #queue for msg destined for ARQ path
self.tx_queue = Queue.Queue()
self.last_rx_time = 0
self.last_rx_rate = 0
self.samples_since_last_rx_time = 0
self.next_interval_start = 0
self.next_transmit_start = 0
self.know_time = False
self.found_time = False
self.found_rate = False
self.set_tag_propagation_policy(extras_swig.TPP_DONT)
self.has_old_msg = False
self.overhead = 15
self.pad_data = numpy.fromstring('this idsaf;lkjkfdjsd;lfjs;lkajskljf;klajdsfk',dtype='uint8')
self.tx_slots_passed = 0
def __init__(self, ):
"""
Two msg ports in, two msg ports out
"""
gr.block.__init__(
self,
name="my_first_msg_block",
in_sig=None,
out_sig=None,
num_msg_inputs=2,
num_msg_outputs=2,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
def __init__(
self,addr,timeout,max_attempts
):
"""
three inputs: radio, from_app, ctrl_in
Three outputs: radio, to_app, ctrl_out
"""
gr.block.__init__(
self,
name = "simple_mac",
in_sig = None,
out_sig = None,
num_msg_inputs = 3,
num_msg_outputs = 3,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.addr = addr #MAC's address
self.pkt_cnt_arq = 0 #pkt_cnt for arq channel
self.pkt_cnt_no_arq = 0 #pkt_cnt for non_arq channel
self.arq_expected_sequence_number = 0 #keep track for sequence error detection
self.no_arq_expected_sequence_number = 0 #keep track for sequence error detection
self.arq_sequence_error_cnt = 0 #arq channel seq errors - VERY BAD
self.no_arq_sequence_error_cnt = 0 #non-arq channel seq error count
self.arq_pkts_txed = 0 #how many arq packets we've transmitted
self.arq_retxed = 0 #how many times we've retransmitted
self.failed_arq = 0
self.max_attempts = max_attempts
self.throw_away = False
self.arq_channel_state = ARQ_CHANNEL_IDLE
self.expected_arq_id = 0 #arq id we're expected to get ack for
self.timeout = timeout #arq timeout parameter
self.time_of_tx = 0.0 #time of last arq transmission
self.queue = Queue.Queue() #queue for msg destined for ARQ path
def __init__(self, port_count):
"""
The inputs are a pmt message blob.
Non-blob messages will be ignored.
"""
gr.block.__init__(
self,
name="virtual_channel_mux",
in_sig=None,
out_sig=None,
num_msg_inputs=port_count,
num_msg_outputs=1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
def __init__(self, hop_interval, post_guard, pre_guard, rx_freq_list, lead_limit, link_bps):
"""
Inputs: complex stream from USRP, pkt in, ctrl in
Outputs: pkt out, ctrl out
"""
gr.block.__init__(
self, name="fhss_engine_rx", in_sig=[numpy.complex64], out_sig=None, num_msg_inputs=2, num_msg_outputs=2
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.hop_interval = hop_interval
self.post_guard = post_guard
self.pre_guard = pre_guard
self.lead_limit = lead_limit
self.link_bps = link_bps
self.rx_freq_list = map(float, rx_freq_list.split(","))
self.rx_freq_list_length = len(self.rx_freq_list)
self.last_rx_time = 0
self.last_rx_rate = 0
self.samples_since_last_rx_time = 0
self.next_interval_start = 0
self.next_transmit_start = 0
self.know_time = False
self.found_time = False
self.found_rate = False
self.set_tag_propagation_policy(gr_extras.TPP_DONT)
self.has_old_msg = False
self.overhead = 20
self.pad_data = numpy.zeros((1, 40), dtype="uint8")[0]
self.tx_slots_passed = 0
self.rx_state = RX_INIT
self.plkt_received = False
self.tune_lead = 0.010
self.rx_hop_index = 0
self.consecutive_miss = 0
def __init__(
self,
):
"""
Two msg ports in, two msg ports out
"""
gr.block.__init__(
self,
name = "my_first_msg_block",
in_sig = None,
out_sig = None,
num_msg_inputs = 2,
num_msg_outputs = 2,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
def __init__(self, addr, timeout, max_attempts):
"""
three inputs: radio, from_app, ctrl_in
Three outputs: radio, to_app, ctrl_out
"""
gr.block.__init__(
self,
name="simple_mac",
in_sig=None,
out_sig=None,
num_msg_inputs=3,
num_msg_outputs=3,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.addr = addr #MAC's address
self.pkt_cnt_arq = 0 #pkt_cnt for arq channel
self.pkt_cnt_no_arq = 0 #pkt_cnt for non_arq channel
self.arq_expected_sequence_number = 0 #keep track for sequence error detection
self.no_arq_expected_sequence_number = 0 #keep track for sequence error detection
self.arq_sequence_error_cnt = 0 #arq channel seq errors - VERY BAD
self.no_arq_sequence_error_cnt = 0 #non-arq channel seq error count
self.arq_pkts_txed = 0 #how many arq packets we've transmitted
self.arq_retxed = 0 #how many times we've retransmitted
self.failed_arq = 0
self.max_attempts = max_attempts
self.throw_away = False
self.arq_channel_state = ARQ_CHANNEL_IDLE
self.expected_arq_id = 0 #arq id we're expected to get ack for
self.timeout = timeout #arq timeout parameter
self.time_of_tx = 0.0 #time of last arq transmission
self.queue = Queue.Queue() #queue for msg destined for ARQ path
def __init__(
self,port_count
):
"""
The inputs are a pmt message blob.
Non-blob messages will be ignored.
"""
gr.block.__init__(
self,
name = "virtual_channel_mux",
in_sig = None,
out_sig = None,
num_msg_inputs = port_count,
num_msg_outputs = 1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
def __init__(
self,
):
"""
Two msg ports in, two msg ports out
"""
gr.block.__init__(
self,
name = "my_first_msg_block",
in_sig = None,
out_sig = None,
num_msg_inputs = 0,#TODO - NOT VALID - specify correct number of ports
num_msg_outputs = 0, #TODO - NOT VALID - specify correct number of ports
)
#we did this for you, this is a blob pmt manager
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
def __init__(self, ):
"""
Two msg ports in, two msg ports out
"""
gr.block.__init__(
self,
name="my_first_msg_block",
in_sig=None,
out_sig=None,
num_msg_inputs=
0, #TODO - NOT VALID - specify correct number of ports
num_msg_outputs=
0, #TODO - NOT VALID - specify correct number of ports
)
#we did this for you, this is a blob pmt manager
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
def __init__(
self,port_count
):
"""
The input is a pmt message blob.
Output are message blobs
"""
gr.block.__init__(
self,
name = "virtual_channel_demux",
in_sig = None,
out_sig = None,
num_msg_inputs = 1,
num_msg_outputs = port_count,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.port_count = port_count
def __init__(self, ):
"""
The input is a stream of bytes.
Outputs a blob with value of current byte if it is different from last.
"""
gr.block.__init__(
self,
name="transition_detect",
in_sig=[numpy.uint8],
out_sig=None,
has_msg_input=False,
num_msg_outputs=1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.old_result = 0
self.key = pmt.pmt_string_to_symbol("example_key")
self.value = pmt.pmt_string_to_symbol("example_value")
self.trans_count = 0
def __init__(self):
"""
First input is a state.
Will hold state staticly until updated received on first input
Will queue messages from second input.
Will pass queued messages to output when state is '0'
"""
gr.block.__init__(
self,
name="channel_access_controller",
in_sig=None,
out_sig=None,
num_msg_inputs=2,
num_msg_outputs=1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.q = Queue.Queue(maxsize=0)
self.channel_state = READY
def __init__(
self,initial_slot,slot_interval,guard_interval,num_slots,lead_limit,link_bps,tx_addr,from_file, mimo
):
"""
Inputs: complex stream from USRP, pkt in, ctrl in
Outputs: pkt out, ctrl out
"""
gr.block.__init__(
self,
name = "tdma_engine",
in_sig = [numpy.complex64],
out_sig = None,
num_msg_inputs = 3,
num_msg_outputs = 2,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.initial_slot = initial_slot
self.num_slots = num_slots
self.prefix_loc = 0
self.prefix_len = 1
self.mimo = mimo
if mimo == True:
self.prefix_loc = initial_slot
print 'prefix_loc = %d' %(self.prefix_loc)
self.prefix_len = 2 # number of PNs
self.initial_slot = 1
self.slot_interval = slot_interval
self.guard_interval = guard_interval
self.lead_limit = lead_limit
self.link_bps = link_bps
self.tx_addr = tx_addr
self.from_file = from_file
self.bytes_per_slot = int( ( self.slot_interval - self.guard_interval ) * self.link_bps / 8 )
self.queue = Queue.Queue() #queue for msg destined for ARQ path
self.tx_queue = Queue.Queue()
self.last_rx_time = 0
self.last_rx_rate = 0
self.samples_since_last_rx_time = 0
self.next_interval_start = 0
self.next_transmit_start = 0
self.know_time = False
self.found_time = False
self.found_rate = False
self.set_tag_propagation_policy(extras_swig.TPP_DONT)
self.has_old_msg = False
self.overhead = 15
#self.pad_data = numpy.fromstring('this idsaf;lkjkfdjsd;lfjs;lkajskljf;klajdsfk',dtype='uint8')
self.pktno = 0
if self.from_file:
txfile_name = '/home/alexzh/' + self.tx_addr + '_randtx'
self.sfile = open(txfile_name, 'r')
self.tx_slots_passed = 0
def __init__(self, initial_slot, slot_interval, guard_interval, num_slots,
lead_limit, link_bps, tx_addr, from_file, mimo):
"""
Inputs: complex stream from USRP, pkt in, ctrl in
Outputs: pkt out, ctrl out
"""
gr.block.__init__(
self,
name="tdma_engine",
in_sig=[numpy.complex64],
out_sig=None,
num_msg_inputs=3,
num_msg_outputs=2,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.initial_slot = initial_slot
self.num_slots = num_slots
self.prefix_loc = 0
self.prefix_len = 1
self.mimo = mimo
if mimo == True:
self.prefix_loc = initial_slot
print 'prefix_loc = %d' % (self.prefix_loc)
self.prefix_len = 2 # number of PNs
self.initial_slot = 1
self.slot_interval = slot_interval
self.guard_interval = guard_interval
self.lead_limit = lead_limit
self.link_bps = link_bps
self.tx_addr = tx_addr
self.from_file = from_file
self.bytes_per_slot = int(
(self.slot_interval - self.guard_interval) * self.link_bps / 8)
self.queue = Queue.Queue() #queue for msg destined for ARQ path
self.tx_queue = Queue.Queue()
self.last_rx_time = 0
self.last_rx_rate = 0
self.samples_since_last_rx_time = 0
self.next_interval_start = 0
self.next_transmit_start = 0
self.know_time = False
self.found_time = False
self.found_rate = False
self.set_tag_propagation_policy(extras_swig.TPP_DONT)
self.has_old_msg = False
self.overhead = 15
#self.pad_data = numpy.fromstring('this idsaf;lkjkfdjsd;lfjs;lkajskljf;klajdsfk',dtype='uint8')
self.pktno = 0
if self.from_file:
txfile_name = '/home/alexzh/' + self.tx_addr + '_randtx'
self.sfile = open(txfile_name, 'r')
self.tx_slots_passed = 0
def __init__(self, device, parity, baudrate, stopbits, bytesize,
wait_for_newline):
"""
Serial port w/ blobs in and out
"""
gr.block.__init__(
self,
name="serial_port",
in_sig=None,
out_sig=None,
num_msg_inputs=1,
num_msg_outputs=1,
)
self.mgr = pmt.pmt_mgr()
for i in range(64):
self.mgr.set(pmt.pmt_make_blob(10000))
self.device = device
self.parity = parity
self.baudrate = baudrate
self.stopbits = stopbits
self.bytesize = bytesize
self.wait_for_newline = wait_for_newline
#set parity
if self.parity == NONE:
self.parity = serial.PARITY_NONE
elif self.parity == EVEN:
self.parity = serial.PARITY_EVEN
else:
self.parity = serial.PARITY_ODD
if self.stopbits == STOPBITS_ONE:
self.stopbits = serial.STOPBITS_ONE
elif self.stopbits == STOPBITS_TWO:
self.stopbits = serial.STOPBITS_TWO
if self.bytesize == WORD_SIZE_7:
self.bytesize = serial.SEVENBITS
else:
self.bytesize = serial.EIGHTBITS
# configure the serial connections (the parameters differs on the device you are connecting to)
self.ser = serial.Serial(port=self.device,
baudrate=self.baudrate,
parity=self.parity,
stopbits=self.stopbits,
bytesize=self.bytesize)
'''
self.ser = serial.Serial(
port=self.device,
baudrate=self.baudrate,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS
)
'''
print "Opened: ", self.ser.portstr # check which port was really used
self.ser.write("hel;lkfsdsa;lkfjdsaflo\n\r") # write a string
