csrichter
/
gr-multirds
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

Fixed decode freq jumping back and forth,fixed rt+ history (deepcopy), consistant piechart colors via defaults, debud and log parameters, fixed unknown symbol crash, fixed smooth_vectors decimation

master
Clemens Richter 9 years ago
parent
40bdf19a5f
commit
4477d3f926
7 changed files with 146 additions and 44 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      cmake/Modules/.directory
  2. 18
      grc/crfa_max_freq.xml
  3. 2
      grc/crfa_rds_decoder.xml
  4. 31
      grc/crfa_rds_parser_table_qt.xml
  5. 27
      python/max_freq.py
  6. 91
      python/rds_parser_table_qt.py
  7. 17
      python/smooth_vectors.py

4
cmake/Modules/.directory
Unescape View File

@ -0,0 +1,4 @@
[Dolphin]
Timestamp=2016,12,6,13,18,42
Version=3
ViewMode=2

18
grc/crfa_max_freq.xml
Unescape View File

@ -4,7 +4,7 @@
<key>crfa_max_freq</key> <key>crfa_max_freq</key>
<category>[crfa]</category> <category>[crfa]</category>
<import>import crfa</import> <import>import crfa</import>
<make>crfa.max_freq($fft_len, $num_decoders, $center_freq, $samp_rate,$round_to)</make> <make>crfa.max_freq($fft_len, $num_decoders, $center_freq, $samp_rate,$round_to,$debug)</make>
<!-- Make one 'param' node for every Parameter you want settable from the GUI. <!-- Make one 'param' node for every Parameter you want settable from the GUI.
Sub-nodes: Sub-nodes:
* name * name
@ -25,6 +25,7 @@
<name>number of decoders</name> <name>number of decoders</name>
<key>num_decoders</key> <key>num_decoders</key>
<type>int</type> <type>int</type>
<hide>part</hide>
</param> </param>
<param> <param>
<name>center frequency</name> <name>center frequency</name>
@ -36,6 +37,21 @@
<key>samp_rate</key> <key>samp_rate</key>
<type>int</type> <type>int</type>
</param> </param>
<param>
<name>Debug</name>
<key>debug</key>
<value>False</value>
<type>bool</type>
<hide>part</hide>
<option>
<name>Enable</name>
<key>True</key>
</option>
<option>
<name>Disable</name>
<key>False</key>
</option>
</param>
<!-- Make one 'sink' node per input. Sub-nodes: <!-- Make one 'sink' node per input. Sub-nodes:

2
grc/crfa_rds_decoder.xml
Unescape View File

@ -5,7 +5,7 @@
<category>[crfa]</category> <category>[crfa]</category>
<import>import crfa</import> <import>import crfa</import>
<make>crfa.rds_decoder($log, $debug)</make> <make>crfa.rds_decoder($log, $debug)</make>
<param> <param>
<name>Log</name> <name>Log</name>
<key>log</key> <key>log</key>
<value>False</value> <value>False</value>

31
grc/crfa_rds_parser_table_qt.xml
Unescape View File

@ -12,9 +12,10 @@
#set $label = '"%s"'%$id #set $label = '"%s"'%$id
#end if #end if
$(signals) = rds_parser_table_qt_Signals() $(signals) = rds_parser_table_qt_Signals()
self.$(id) = crfa.rds_parser_table_qt($(signals),$nPorts,self.set_$(freq_tune),$freq_tune) self.$(id) = crfa.rds_parser_table_qt($(signals),$nPorts,self.set_$(freq_tune),$freq_tune,$log, $debug)
$(win) = rds_parser_table_qt_Widget($signals, $label,self.$(id)) $(win) = rds_parser_table_qt_Widget($signals, $label,self.$(id))
$(gui_hint()($win))</make> $(gui_hint()($win))</make>
<callback>set_freq_tune($freq_tune);</callback>
<param> <param>
<name>tuned frequency</name> <name>tuned frequency</name>
<key>freq_tune</key> <key>freq_tune</key>
@ -42,6 +43,34 @@ $(gui_hint()($win))</make>
<type>int</type> <type>int</type>
<hide>part</hide> <hide>part</hide>
</param> </param>
<param>
<name>Log</name>
<key>log</key>
<value>False</value>
<type>bool</type>
<option>
<name>Enable</name>
<key>True</key>
</option>
<option>
<name>Disable</name>
<key>False</key>
</option>
</param>
<param>
<name>Debug</name>
<key>debug</key>
<value>False</value>
<type>bool</type>
<option>
<name>Enable</name>
<key>True</key>
</option>
<option>
<name>Disable</name>
<key>False</key>
</option>
</param>
<sink> <sink>
<name>in</name> <name>in</name>
<type>message</type> <type>message</type>

27
python/max_freq.py
Unescape View File

@ -27,7 +27,7 @@ class max_freq(gr.sync_block):
""" """
docstring for block max_freq docstring for block max_freq
""" """
def __init__(self, fft_len=1024,num_decoders=4,center_freq=0,samp_rate=0,round_to=100e3): def __init__(self, fft_len=1024,num_decoders=4,center_freq=0,samp_rate=0,round_to=100e3,debug=False):
gr.sync_block.__init__(self, gr.sync_block.__init__(self,
name="max_freq", name="max_freq",
in_sig=[(np.float32,fft_len)], in_sig=[(np.float32,fft_len)],
@ -37,6 +37,8 @@ class max_freq(gr.sync_block):
self.center_freq=center_freq self.center_freq=center_freq
self.samp_rate=samp_rate self.samp_rate=samp_rate
self.snapto=round_to self.snapto=round_to
self.debug=debug
self.last_station_freqs=[]
self.message_port_register_out(pmt.intern('out')) self.message_port_register_out(pmt.intern('out'))
def set_center_freq(self, freq=None): def set_center_freq(self, freq=None):
if freq is not None: if freq is not None:
@ -90,23 +92,34 @@ class max_freq(gr.sync_block):
if count>=min_consec_max_threshold: if count>=min_consec_max_threshold:
threshold_reached=True threshold_reached=True
last_index=i last_index=i
#sort station_indices by signal strength #sort station_indices by signal strength (dont bother decoding quiet stations)
station_indices_sorted=sorted(station_indices,key=lambda elem:numbers[elem],reverse=True) station_indices_sorted=sorted(station_indices,reverse=True,key=lambda elem:numbers[elem])
#prevents back and forth switching if two station have similar signal strength
station_indices_tune=list(station_indices_sorted)#copy list
del station_indices_tune[self.num_decoders:]#remove non decodable incidices
station_indices_tune.sort()
station_strength=[]
station_freqs=[] station_freqs=[]
#index to freq: #index to freq:
for index in station_indices_sorted: for index in station_indices_tune:
startfreq=self.center_freq-self.samp_rate/2 startfreq=self.center_freq-self.samp_rate/2
freq=self.samp_rate*index/self.fft_len+startfreq freq=self.samp_rate*index/self.fft_len+startfreq
num_decimals=int(round(math.log(self.snapto,10))) num_decimals=int(round(math.log(self.snapto,10)))
station_freqs.append(round(freq,-num_decimals)) station_freqs.append(round(freq,-num_decimals))
station_strength.append(round(numbers[index],-2))
for i in range(0,min(self.num_decoders,len(station_freqs))): for i in range(0,min(self.num_decoders,len(station_freqs))):
msg_string=str(i+1)+" "+str(station_freqs[i]) msg_string=str(i+1)+" "+str(station_freqs[i])
send_pmt = pmt.string_to_symbol(msg_string) send_pmt = pmt.string_to_symbol(msg_string)
self.message_port_pub(pmt.intern('out'), send_pmt) self.message_port_pub(pmt.intern('out'), send_pmt)
print(max_indices) if self.debug:
print(station_indices_sorted) print(max_indices)
print(station_freqs) print(station_indices_sorted)
print(station_indices_tune)
print(station_strength)
print(station_freqs)
self.last_station_freqs=station_freqs
return len(input_items[0]) return len(input_items[0])

91
python/rds_parser_table_qt.py
Unescape View File

@ -21,7 +21,7 @@
from __future__ import print_function#print without newline print('.', end="") from __future__ import print_function#print without newline print('.', end="")
import numpy import numpy
from gnuradio import gr from gnuradio import gr
import pmt,functools,csv,md5,collections import pmt,functools,csv,md5,collections,copy
from datetime import datetime from datetime import datetime
import crfa.chart as chart import crfa.chart as chart
@ -40,7 +40,7 @@ class rds_parser_table_qt(gr.sync_block):
""" """
docstring for block qtguitest docstring for block qtguitest
""" """
def __init__(self,signals,nPorts,slot,freq): def __init__(self,signals,nPorts,slot,freq,log,debug):
#QObject.__init__() #QObject.__init__()
gr.sync_block.__init__(self, gr.sync_block.__init__(self,
name="RDS Table", name="RDS Table",
@ -51,6 +51,8 @@ class rds_parser_table_qt(gr.sync_block):
self.set_msg_handler(pmt.intern('in%d'%i), functools.partial(self.handle_msg, port=i)) self.set_msg_handler(pmt.intern('in%d'%i), functools.partial(self.handle_msg, port=i))
self.message_port_register_in(pmt.intern('freq')) self.message_port_register_in(pmt.intern('freq'))
self.set_msg_handler(pmt.intern('freq'), self.set_freq) self.set_msg_handler(pmt.intern('freq'), self.set_freq)
self.log=log
self.debug=debug
self.signals=signals self.signals=signals
self.RDS_data={} self.RDS_data={}
self.change_freq_tune=slot self.change_freq_tune=slot
@ -60,9 +62,10 @@ class rds_parser_table_qt(gr.sync_block):
self.TMC_data={} self.TMC_data={}
self.decoder_frequencies={} self.decoder_frequencies={}
self.colorder=['ID','freq','name','PTY','AF','time','text','quality','buttons'] self.colorder=['ID','freq','name','PTY','AF','time','text','quality','buttons']
#workdir="/user/wire2/richter/hackrf_prototypes/" #workdir=""
workdir="/media/clemens/intdaten/uni_bulk/forschungsarbeit/hackrf_prototypes/" workdir="/user/wire2/richter/hackrf_prototypes/"
reader = csv.reader(open(workdir+'RDS_ODA AIDs_names_only.csv'), delimiter=',', quotechar='"') #workdir="/media/clemens/intdaten/uni_bulk/forschungsarbeit/hackrf_prototypes/"
reader = csv.reader(open(workdir+'RDS_ODA-AIDs_names_only.csv'), delimiter=',', quotechar='"')
reader.next()#skip header reader.next()#skip header
for row in reader: for row in reader:
self.ODA_application_names[int(row[0])]=row[1] self.ODA_application_names[int(row[0])]=row[1]
@ -84,6 +87,14 @@ class rds_parser_table_qt(gr.sync_block):
reader.next()#skip header reader.next()#skip header
self.pty_dict=dict((int(rows[0]),rows[1]) for rows in reader) self.pty_dict=dict((int(rows[0]),rows[1]) for rows in reader)
f.close() f.close()
def set_freq_tune(self,freq):
self.tuning_frequency=int(freq)
message_string="decoder frequencies:"
for num in self.decoder_frequencies:
freq=self.decoder_frequencies[num]
message_string+="\t %i:%0.1fM"% (num,freq/1e6)
message_string+="\t tuned frequency:%0.1fM"%(self.tuning_frequency/1e6)
self.signals.DataUpdateEvent.emit({'decoder_frequencies':message_string})
def set_freq(self,msg): def set_freq(self,msg):
m = pmt.symbol_to_string(msg) m = pmt.symbol_to_string(msg)
decoder_num=int(m.split()[0])-1#msgs are 1-indexed, decoder_num is 0-indexed decoder_num=int(m.split()[0])-1#msgs are 1-indexed, decoder_num is 0-indexed
@ -104,7 +115,9 @@ class rds_parser_table_qt(gr.sync_block):
#print("nr:%i freq:%s"%(tgtnum,freq_str)) #print("nr:%i freq:%s"%(tgtnum,freq_str))
def init_data_for_PI(self,PI): def init_data_for_PI(self,PI):
self.RDS_data[PI]={} self.RDS_data[PI]={}
self.RDS_data[PI]["blockcounts"]={} #self.RDS_data[PI]["blockcounts"]={}# no defaults (works aswell)
#defaults are to keep colors in piechart consistent between stations:
self.RDS_data[PI]["blockcounts"]={"0A":0,"1A":0,"2A":0,"3A":0,"4A":0,"6A":0,"8A":0,"12A":0,"14A":0}
self.RDS_data[PI]["blockcounts"]["any"]=0 self.RDS_data[PI]["blockcounts"]["any"]=0
self.RDS_data[PI]["AID_list"]={} self.RDS_data[PI]["AID_list"]={}
self.RDS_data[PI]["PSN"]="_"*8 self.RDS_data[PI]["PSN"]="_"*8
@ -132,7 +145,8 @@ class rds_parser_table_qt(gr.sync_block):
#initialize dict 1st packet from station: #initialize dict 1st packet from station:
if not self.RDS_data.has_key(PI): if not self.RDS_data.has_key(PI):
self.init_data_for_PI(PI) self.init_data_for_PI(PI)
print("found station %s"%PI) if self.log:
print("found station %s"%PI)
if self.decoder_frequencies.has_key(port): if self.decoder_frequencies.has_key(port):
freq=self.decoder_frequencies[port] freq=self.decoder_frequencies[port]
@ -169,13 +183,15 @@ class rds_parser_table_qt(gr.sync_block):
freq=self.decode_AF_freq(array[4]) freq=self.decode_AF_freq(array[4])
if freq==self.RDS_data[PI]["tuned_freq"]: if freq==self.RDS_data[PI]["tuned_freq"]:
self.RDS_data[PI]["AF"]["main"]=freq self.RDS_data[PI]["AF"]["main"]=freq
print("main frequency found in 0A: station:%s, freq:%0.1fM"% (self.RDS_data[PI]["PSN"],freq/1e6)) if self.log:
print("main frequency found in 0A: station:%s, freq:%0.1fM"% (self.RDS_data[PI]["PSN"],freq/1e6))
freq_str="0A:%0.1fM"% (freq/1e6) freq_str="0A:%0.1fM"% (freq/1e6)
self.signals.DataUpdateEvent.emit({'PI':PI,'freq':freq_str}) self.signals.DataUpdateEvent.emit({'PI':PI,'freq':freq_str})
freq=self.decode_AF_freq(array[5]) freq=self.decode_AF_freq(array[5])
if freq==self.RDS_data[PI]["tuned_freq"]: if freq==self.RDS_data[PI]["tuned_freq"]:
self.RDS_data[PI]["AF"]["main"]=freq self.RDS_data[PI]["AF"]["main"]=freq
print("main frequency found in 0A: station:%s, freq:%0.1fM"% (self.RDS_data[PI]["PSN"],freq/1e6)) if self.log:
print("main frequency found in 0A: station:%s, freq:%0.1fM"% (self.RDS_data[PI]["PSN"],freq/1e6))
freq_str="0A:%0.1fM"% (freq/1e6) freq_str="0A:%0.1fM"% (freq/1e6)
self.signals.DataUpdateEvent.emit({'PI':PI,'freq':freq_str}) self.signals.DataUpdateEvent.emit({'PI':PI,'freq':freq_str})
if(array[4]>= 224 and array[4]<= 249): if(array[4]>= 224 and array[4]<= 249):
@ -229,7 +245,8 @@ class rds_parser_table_qt(gr.sync_block):
language_codes=SLC language_codes=SLC
elif variant==6: elif variant==6:
#for use by broadcasters #for use by broadcasters
print("PI:%s PSN:%s uses variant 6 of 1A"%(PI,self.RDS_data[PI]["PSN"])) if self.debug:
print("PI:%s PSN:%s uses variant 6 of 1A"%(PI,self.RDS_data[PI]["PSN"]))
elif variant==7: elif variant==7:
ESW_channel_identification=SLC ESW_channel_identification=SLC
PIN_day=(PIN>>11)&0x1f PIN_day=(PIN>>11)&0x1f
@ -298,12 +315,18 @@ class rds_parser_table_qt(gr.sync_block):
app_group=str(app_group_raw >> 1)+"B" app_group=str(app_group_raw >> 1)+"B"
if not self.RDS_data[PI]["AID_list"].has_key(AID):#new ODA found if not self.RDS_data[PI]["AID_list"].has_key(AID):#new ODA found
app_name=self.ODA_application_names[AID] try:
app_name=self.ODA_application_names[AID]
except KeyError:
if self.debug:
print("ERROR: ODA-app-id (AID) '%i' not found in list on station %s, app group:%s"%(AID,app_group,PI))
app_name="unknown"
self.RDS_data[PI]["AID_list"][AID]={} self.RDS_data[PI]["AID_list"][AID]={}
self.RDS_data[PI]["AID_list"][AID]["groupType"]=app_group self.RDS_data[PI]["AID_list"][AID]["groupType"]=app_group
self.RDS_data[PI]["AID_list"][AID]["app_name"]=app_name self.RDS_data[PI]["AID_list"][AID]["app_name"]=app_name
self.RDS_data[PI]["AID_list"][AID]["app_data"]=app_data self.RDS_data[PI]["AID_list"][AID]["app_data"]=app_data
print("new ODA: AID:%i, name:%s, app_group:%s, station:%s" %(AID,app_name,app_group,PI)) if self.log:
print("new ODA: AID:%i, name:%s, app_group:%s, station:%s" %(AID,app_name,app_group,PI))
#decode 3A group of TMC #decode 3A group of TMC
if AID==52550:#TMC alert-c if AID==52550:#TMC alert-c
variant=app_data>>14 variant=app_data>>14
@ -321,7 +344,7 @@ class rds_parser_table_qt(gr.sync_block):
activity_time=(app_data>>4)&0x3 activity_time=(app_data>>4)&0x3
window_time=(app_data>>2)&0x3 window_time=(app_data>>2)&0x3
delay_time=(app_data>>0)&0x3 delay_time=(app_data>>0)&0x3
else: elif self.debug:
print("unknown variant %i in TMC 3A group"%variant) print("unknown variant %i in TMC 3A group"%variant)
elif (groupType == "4A"):#CT clock time elif (groupType == "4A"):#CT clock time
datecode=((array[3] & 0x03) << 15) | (array[4] <<7)|((array[5] >> 1) & 0x7f) datecode=((array[3] & 0x03) << 15) | (array[4] <<7)|((array[5] >> 1) & 0x7f)
@ -393,13 +416,16 @@ class rds_parser_table_qt(gr.sync_block):
if 4 <= adr and adr <= 9: if 4 <= adr and adr <= 9:
#seen variants 4569, 6 most often #seen variants 4569, 6 most often
#print("TMC-info variant:%i"%adr) #print("TMC-info variant:%i"%adr)
if adr== 7: if adr== 7:#freq of tuned an mapped station (not seen yet)
freq=tmc_y>>8 freq_TN=tmc_y>>8
print("TMC-info: TN:%i"%freq) freq_ON=tmc_y&0xff#mapped frequency
self.RDS_data[PI]["TMC_TN"]=freq if self.debug:
print("TMC-info: TN:%i"%freq_TN)
self.RDS_data[PI]["TMC_TN"]=freq_TN
else: else:
a=0 a=0
print("alert plus") if self.debug:
print("alert plus")#(not seen yet)
#RadioText+ (grouptype mostly 12A): #RadioText+ (grouptype mostly 12A):
@ -426,10 +452,11 @@ class rds_parser_table_qt(gr.sync_block):
tag2_len=int(tag2&(2**5-1)) tag2_len=int(tag2&(2**5-1))
if not self.RDS_data[PI]["RT+"]["last_item_toggle_bit"] == item_toggle_bit: #new item if not self.RDS_data[PI]["RT+"]["last_item_toggle_bit"] == item_toggle_bit: #new item
#self.RDS_data[PI]["RT+"]["history"][str(datetime.now())]=self.RDS_data[PI]["internals"]["last_rt_tooltip"] #self.RDS_data[PI]["RT+"]["history"][str(datetime.now())]=self.RDS_data[PI]["internals"]["last_rt_tooltip"]
self.RDS_data[PI]["RT+_history"][str(datetime.now())]=self.RDS_data[PI]["RT+"]#save old item self.RDS_data[PI]["RT+_history"][str(datetime.now())]=copy.deepcopy(self.RDS_data[PI]["RT+"])#save old item
self.RDS_data[PI]["RT+"]["last_item_toggle_bit"] = item_toggle_bit self.RDS_data[PI]["RT+"]["last_item_toggle_bit"] = item_toggle_bit
rtcol=self.colorder.index('text') rtcol=self.colorder.index('text')
print("toggle bit changed on PI:%s, cleared RT-tt"%PI) if self.debug:
print("toggle bit changed on PI:%s, cleared RT-tt"%PI)
self.signals.DataUpdateEvent.emit({'col':rtcol,'row':port,'PI':PI,'tooltip':""}) self.signals.DataUpdateEvent.emit({'col':rtcol,'row':port,'PI':PI,'tooltip':""})
if self.RDS_data[PI].has_key("RT"): if self.RDS_data[PI].has_key("RT"):
rt=self.RDS_data[PI]["RT"] rt=self.RDS_data[PI]["RT"]
@ -470,7 +497,8 @@ class rds_parser_table_qt(gr.sync_block):
if not self.RDS_data.has_key(PI_ON): if not self.RDS_data.has_key(PI_ON):
self.init_data_for_PI(PI_ON) self.init_data_for_PI(PI_ON)
self.RDS_data[PI_ON]["TP"]=TP_ON self.RDS_data[PI_ON]["TP"]=TP_ON
print("found station %s via EON on station %s"%(PI_ON,PI)) if self.log:
print("found station %s via EON on station %s"%(PI_ON,PI))
if not self.RDS_data[PI]["EON"].has_key(PI_ON): if not self.RDS_data[PI]["EON"].has_key(PI_ON):
self.RDS_data[PI]["EON"][PI_ON]={} self.RDS_data[PI]["EON"][PI_ON]={}
self.RDS_data[PI]["EON"][PI_ON]["PSN"]="_"*8 self.RDS_data[PI]["EON"][PI_ON]["PSN"]="_"*8
@ -510,17 +538,20 @@ class rds_parser_table_qt(gr.sync_block):
#formatted_text="<font face='Courier New' color='%s'>%s</font>"%("purple",PS_ON_str) #formatted_text="<font face='Courier New' color='%s'>%s</font>"%("purple",PS_ON_str)
self.signals.DataUpdateEvent.emit({'PI':PI_ON,'PSN':formatted_text}) self.signals.DataUpdateEvent.emit({'PI':PI_ON,'PSN':formatted_text})
if variant==4:#AF_ON if variant==4:#AF_ON
print("AF_ON method A")#TODO if self.debug:
print("AF_ON method A")#TODO
if variant in range(5,10):#variant 5..9 -> mapped freqs if variant in range(5,10):#variant 5..9 -> mapped freqs
freq_TN=self.decode_AF_freq(array[4]) freq_TN=self.decode_AF_freq(array[4])
freq_ON=self.decode_AF_freq(array[5]) freq_ON=self.decode_AF_freq(array[5])
#lock in tuned network if freq_TN matches decoder frequency #lock in tuned network if freq_TN matches decoder frequency
if(self.RDS_data[PI].has_key("tuned_freq") and freq_TN==self.RDS_data[PI]["tuned_freq"]and not self.RDS_data[PI]["AF"].has_key("main")): if(self.RDS_data[PI].has_key("tuned_freq") and freq_TN==self.RDS_data[PI]["tuned_freq"]and not self.RDS_data[PI]["AF"].has_key("main")):
print("main frequency found: station:%s, freq:%0.1fM"% (self.RDS_data[PI]["PSN"],freq_TN/1e6)) if self.log:
print("main frequency found: station:%s, freq:%0.1fM"% (self.RDS_data[PI]["PSN"],freq_TN/1e6))
self.RDS_data[PI]["AF"]["main"]=freq_TN self.RDS_data[PI]["AF"]["main"]=freq_TN
#lock in ON if TN is locked in #lock in ON if TN is locked in
if(self.RDS_data[PI]["AF"].has_key("main") and self.RDS_data[PI]["AF"]["main"]==freq_TN and not self.RDS_data[PI_ON]["AF"].has_key("main")): if(self.RDS_data[PI]["AF"].has_key("main") and self.RDS_data[PI]["AF"]["main"]==freq_TN and not self.RDS_data[PI_ON]["AF"].has_key("main")):
print("mapped frequency found: station:%s, freq:%0.1fM"% (self.RDS_data[PI_ON]["PSN"],freq_ON/1e6)) if self.log:
print("mapped frequency found: station:%s, freq:%0.1fM"% (self.RDS_data[PI_ON]["PSN"],freq_ON/1e6))
self.RDS_data[PI_ON]["AF"]["main"]=freq_ON self.RDS_data[PI_ON]["AF"]["main"]=freq_ON
freq_str="EON:%0.1fM"% (freq_ON/1e6) freq_str="EON:%0.1fM"% (freq_ON/1e6)
self.signals.DataUpdateEvent.emit({'PI':PI_ON,'freq':freq_str}) self.signals.DataUpdateEvent.emit({'PI':PI_ON,'freq':freq_str})
@ -538,15 +569,15 @@ class rds_parser_table_qt(gr.sync_block):
PIN_ON=(array[4]<<8)|(array[5]) PIN_ON=(array[4]<<8)|(array[5])
#else:#other group #else:#other group
if 1==1: if 1==1:
#printdelay=50
printdelay=500
self.printcounter+=0#printing disabled
if self.RDS_data[PI]["blockcounts"].has_key(groupType): if self.RDS_data[PI]["blockcounts"].has_key(groupType):
self.RDS_data[PI]["blockcounts"][groupType] +=1 #increment self.RDS_data[PI]["blockcounts"][groupType] +=1 #increment
else: else:
self.RDS_data[PI]["blockcounts"][groupType] = 1 #initialize (1st group of this type) self.RDS_data[PI]["blockcounts"][groupType] = 1 #initialize (1st group of this type)
if self.printcounter == printdelay: #printdelay=50
printdelay=500
self.printcounter+=0#printing disabled
if self.printcounter == printdelay and self.debug:
#code.interact(local=locals()) #code.interact(local=locals())
for key in self.RDS_data: for key in self.RDS_data:
if self.RDS_data[key].has_key("PSN"): if self.RDS_data[key].has_key("PSN"):
@ -598,7 +629,7 @@ class rds_parser_table_qt(gr.sync_block):
try: try:
charlist[i]=alphabet[alnr][index] charlist[i]=alphabet[alnr][index]
except KeyError: except KeyError:
charlist[i]=char charlist[i]='?'#symbol not decoded #TODO
pass pass
return "".join(charlist) return "".join(charlist)
def color_text(self, text, start,end,textcolor,segmentcolor): def color_text(self, text, start,end,textcolor,segmentcolor):

17
python/smooth_vectors.py
Unescape View File

@ -21,6 +21,7 @@
import numpy as np import numpy as np
from gnuradio import gr from gnuradio import gr
import code
class smooth_vectors(gr.decim_block): class smooth_vectors(gr.decim_block):
""" """
@ -30,22 +31,30 @@ class smooth_vectors(gr.decim_block):
gr.decim_block.__init__(self, gr.decim_block.__init__(self,
name="smooth_vectors", name="smooth_vectors",
in_sig=[(np.float32,vec_len)], in_sig=[(np.float32,vec_len)],
out_sig=[(np.float32,vec_len)], decim=decim) out_sig=[(np.float32,vec_len)],
decim=decim)
self.vec_len=vec_len self.vec_len=vec_len
self.decim=decim self.decim=decim
self.moving_avg_len=moving_avg_len self.moving_avg_len=moving_avg_len
self.last_inputs=[] self.last_inputs=[]
self.count=0 #self.count=1
def work(self, input_items, output_items): def work(self, input_items, output_items):
in0 = input_items[0] in0 = input_items[0]#0th input port?
out = output_items[0] out = output_items[0]
self.last_inputs.insert(0,in0) #self.last_inputs.insert(0,in0)
#code.interact(local=locals())
for i in range(0,self.decim):
self.last_inputs.insert(0,in0[i])
out[:] =np.mean( np.array(self.last_inputs), axis=0 ) out[:] =np.mean( np.array(self.last_inputs), axis=0 )
# <+signal processing here+> # <+signal processing here+>
if len(self.last_inputs)>self.moving_avg_len: if len(self.last_inputs)>self.moving_avg_len:
self.last_inputs.pop(len(self.last_inputs)-1)#remove last self.last_inputs.pop(len(self.last_inputs)-1)#remove last
#out[:] = in0 #out[:] = in0
#self.count += 1
return len(output_items[0]) return len(output_items[0])

Write Preview
Loading…
Cancel
Save