8. USRP
8.3 USRP İle Yapılan Uygulamalar
8.3.3 USRP ve GNU Radyo Kullanarak MP3 Dosya İletimi
Bu deneyde ses dosyası kablosuz olarak iletimi incelenmiştir. Bunu için bir liste oluşturup MP3 formatındaki ses dosyalarını .raw uzantılı dosyalara dönüştürülecektir. Bunun nedeni GNU radyonun .raw uzantılı dosyaların iletimine destek vermesidir. Bunun için Linux işletim sisteminde sox komutu kullanılacaktır.Örneğin sox komutunun kullanımı şu şekildedir:
sox test.mp3 -r 32000 -t raw -l -c 1 test.raw
Aşağıda örnek bir müzik listesi vardır.
ekil 8.14:iletim için kullanılacak olan müzik listesi
Kullanılan kodun temeli GNU radyodaki fm_tx4.py ye dayanmaktadır. Ayrıca sinyal işleme içinde wfm_tx() blok kodu kullanılmıştır bu geniş band FM iletimi sağlar.bu sayede sinyalin FM modulasyonu yapılacaktır.Sonuç olarak USRP ve GNU radyo kullanılarak müzik dosyası temel TX kartından gönderilip temel RX kartından alınabilecek formata gelmiş olacaktır.Ayrıca FM modülasyonu yerine 64 QAM modülasyon kullanarak denemeler yapılmıştır.
Çalıştırmamız gereken kod : Sudo python “dosyaismi.py” -1 “listeismi.pls”
9. SONUÇLAR ve ÖNERİLER
Bu çalışmada IEEE 802.22 WRAN sistemi, PHY MAC katmanları ve bu sistemde kullanılacak olan bilişsel radyo araştırılmıştır. BR, SDR teknolojisinin üzerine inşa edilmektedir. BR teknolojisi kendi kendine öğrenebilmeyi olanaklı kılar, “Cognitive” fonksiyonların çalışmasına izin verir ve daha güçlü haberleşme sağlayabilmek için boş spektrumların kullanılmasını ve saptanmasını sağlar. BR’ler çalıştıkları ortamı sezebilirler ve davranışlarını ortama göre adapte edebilirler. BR içinde yazılım cihazlarının gömülü olduğu bir makine vardır ve protokoller onun için yüklenir. Böylece radyo akıllı olabilir ve bulunduğu ortamı inceleyebilir. Örneğin, bir BR kullanıcılarının aktivitelerini tespit ederek, onların ilgi gösterdiği servisleri öğrenebilir. Radyo bu servisleri nasıl bulacağını ve kullanıcıların bunlara ilgi gösterme olasılıklarını bilir. Örnek olarak, BR, kullanıcılarının TV bandındaki bilgilerine bakarak, spektrumda kullanılmayan yada boş olan kanalları fark edebilir. BR kablosuz bir LAN’ daki ve telefon ağındaki meşgul olmayan alanları saptayabilir. Böylece radyo kaynakları yani spektrum, lisanslı servislere etki etmeyecek şekilde paylaştırılmış oluyor. Radyo işletim karakteristiği gerçek zamanlı olarak BR sayesinde esnek kullanım kolaylığı, verimli ve güvenli spektrum kullanımı sağlayacaktır.
USRP ve GNU radyo araştırılarak bilişsel radyo ve yazılım tanımlı radyoya ilişkin yazılımsal uygulamalar yapılmıştır. Bu uygulamalardan ilki USRP kullanarak geniş band FM VHF RX / dar band FM VHF TX alıcı verici yapısının oluşturulmasıdır. İkincisi ise ses iletimini gerçekleştiren alıcı verici yapısı tasarımıdır. Ve son olarak USRP ve GNU radyo ile MP3 dosyasının iletilmesidir.
Bu çalışmada yazılım tanımlı radyo ve bilişsel radyoya ilişkin yazılımsal uygulamalar USRP cihazı kullanılarak oluşturulmuştur. Sonuç olarak donanımsal farklılıklar yerine yazılımsal değişiklikler sayesinde cihazları daha etkin kullanabilmesi gösterilmiştir.
KAYNAKLAR
[1] IEEE Std 802.11-1999TM , USA,1999 [2] IEEE Std 802.15.3-2003TM, USA, 2003. [3] IEEE Std 802.16-2004TM, USA 2004.
[4] http://www.ieee802.org/20/, (Ziyaret tarihi: 10 Aralık 2008). [5] http://www.ieee802.org/21/, (Ziyaret tarihi: 10 Aralık 2008). [6] http://www.ieee802.org/22/, (Ziyaret tarihi: 10 Aralık 2008).
[7] C. Cordeiro, K. Challapali, D. Birru, and N. Sai Shankar, “IEEE 802.22: an introduction to the first wireless standard based on cognitive radios”, Journal of
Communications, 38–47, 2006
[8] Carl R. Stevenson, Carlos Cordeiro, Eli Sofer and Gerald Chouinard, “Functional
Requirements for the 802.22 WRAN Standard”,IEEE 802.22-05/0007r46,2005
[9] http://www.ieee802.org/22/22-04-0003-00-0000_WRAN_System_Concept.ppt
IEEE 802.16.3-00/02r4,2005
[10] C. Cordeiro, K. Challapali, D. Birru, and N. Sai Shankar, “Cognitive Radio Oriented Wireless Networks and Communications”, 2007. CrownCom 2007. 2nd
International Conference on, 225-233, 1-3 Ağu. 2007
[11]C. Cordeiro, K. Challapali, and M. Ghosh, “Cognitive PHY and MAC. Layer for Dynamic Spectrum Access and Sharing of TV Bands,” TAPAS’06, First International Workshop on Technology and Policy for Accessing
Spectrum,2006.
[12]“IEEE 802 Part 22.1: Enhanced Protection for Low-Power, Licensed Devices Operating in Television Broadcast Bands May 2007, P802.22.1/D1” in IEEE 802.22.
[13]Ning Han; SungHwan Shon; Jae Hak Chung; Jae Moung Kim “Spectral Correlation Based Signal Detection Method for Spectrum Sensing in IEEE 802.22 WRAN Systems” Advanced Communication Technology, 2006. ICACT 2006. The
8th International Conference , 6 – 1770, 20-22 şubat. 2006
[15]http://www.cognitiveradio.wireless.vt.edu/radiohas.html (Ziyaret tarihi: 10 Aralık 2008).
[16]http://www.gnu.org/software/gnuradio/ (Ziyaret tarihi: 10 Aralık 2008)
[17] Ian F. Akyildiz, Won-Yeol Lee, Mehmet C. Vuran, and Shantidev Mohanty, “NeXt generation/dynamic spectrum access/cognitive radio wireless networks : A survey,” Computer Networks: The International Journal of Computer and
Telecommunications Networking, 2127-2159, 2006.
[18] www.ettus.com(Ziyaret tarihi: 10 Aralık 2008).
[19] F. A. Hamza “The USRP under 1.5X Magnifying Lens!”, GNU Radio project ,12 Haz.2008
EK-A
Tablo 5.6: MAC katmanı sabitleri
Sabit Açıklama
adres Bir cihaza atanan 48 bitlik IEEE
adresi
aMaxMissedKontrol işaretis SPD tarafının bir üst katmana gönderilen art arda kaybedilen kontrol işaretlerin sayısını gösterir.
aMaxKontrol işaretiOverhead En fazla sayıda octet kombinasyonu içeren MHR ve MFR.
EK-B
Tablo 5.7: MIB(MAC Information Base- MAC bilgi tabanı) Simgeleri
Simge Tip aralık Açıklama Default
amacAntennaHeight Boolean 0 yada 1 Kontrol işareti çerçevesini ileten antenin yerden yüksekliği 0 30 metreden az ve eşit olduğunu, 1 30 metreden fazla olduğunu gösterir 0
macIndoorOutdoor Boolean 0 yada 1 Korunan cihazın alıcı anteninin yeri. O antenin dışarıda, 1 ise içeride olduğunu gösterir 0
macKontrol işaretiLocation TBD 0 yada 1 Başlangıç kontrol işareti çerçevesinin yeri
macCeaseTx Boolean 0 yada 1 Cihazın iletimi
durdurmayı planlayıp planlamadığını gösterir. 1 durdurmak istediğini, 0 iletime devam etmek istediğini gösterir. 0
macChannelWidth Integer 0x00-0x02 İletim cihazı tarafından korunan kanalın genişliği
Alana bağlı
macFrameVersionNumber Integer 0x00–0x07 İletilen çerçevelere eklenecek versiyon numarası
0x00
macKeepOutZone Boolean 0 yada 1 Kontrol işareti çerçevesiyle korunan alanın metre cinsinden yarıçapı. 500 m’ den küçükse 0, büyükse 1. 0
macNumSyncBursts Integer Kontrol işareti
çerçevesi gönderilmeden önce gönderilen senkronizasyon burstlerinin sayısı macPPDAddress IEEE address 48 bitlik IEEE adresi PPD’nin 48 bitlik adresi _
macPriorityLevel Integer 0x00–0x07 Servis önceliği macProtectingDeviceRank Boolean 0 yada 1 Koruyucu
cihazın sınıfı. 0 SPD’ yi, 1 PPD’ yi temsil eder.
0
macRequiredNeedTimer Integer 0x00–0x7f Kanalın ne kadar sure daha meşgul edileceğini gösteren nümerik değer. 0x00 değeri 0x00
kanalın ne kadar sure daha meşgul edileceğinin belirsiz olduğunu gösterir.
macSubchannelMap Bitmap 40 bit alan Meşgul edilen kanalın alt kanalları
EK – C Ses-tx.py
#!/usr/bin/env python
from gnuradio import gr, gru, modulation_utils from gnuradio import usrp
from gnuradio import eng_notation
from gnuradio.eng_option import eng_option from optparse import OptionParser
import random, time, struct, sys # from current dir
from transmit_path import transmit_path import fusb_options
#import os #print os.getpid()
#raw_input('Attach and press enter') class my_graph(gr.flow_graph):
def __init__(self, modulator_class, options): gr.flow_graph.__init__(self)
self.txpath = transmit_path(self, modulator_class, options)
#/////////////////////////////////////////////////////////////////// # main
#/////////////////////////////////////////////////////////////////// def main():
def send_pkt(payload='', eof=False): return fg.txpath.send_pkt(payload, eof) def rx_callback(ok, payload):
print "ok = %r, payload = '%s'" % (ok, payload) mods = modulation_utils.type_1_mods()
parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(), default='gmsk',
help="Select modulation from: %s [default=%%default]" % (', '.join(mods.keys()),))
parser.add_option("-s", "--size", type="eng_float", default=1500, help="set packet size [default=%default]")
parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]")
parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinous transmission (bursts of 5 packets)") parser.add_option("","--from-file", default=None,
transmit_path.add_options(parser, expert_grp) for mod in mods.values():
mod.add_options(expert_grp) fusb_options.add_options(expert_grp) (options, args) = parser.parse_args () if len(args) != 0:
parser.print_help() sys.exit(1)
if options.tx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr)
sys.exit(1)
if options.from_file is not None:
source_file = open(options.from_file, 'r') #print 'zhifeng: from file'
#print 'source_file = ', source_file
# build the graph
fg = my_graph(mods[options.modulation], options) r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling" #print dir(object)
#print dir(fg) #raw_input('zhifeng')
fg.start() # start flow graph # generate and send packets
nbytes = int(1e6 * options.megabytes) n = 0
pktno = 0
pkt_size = int(options.size) while n < nbytes:
if options.from_file is None:
data = (pkt_size - 2) * chr(pktno & 0xff) #print 'zhifeng: ', 'data = ',data
#raw_input('press any key to continue')
else:
data = source_file.read(pkt_size - 2) if data == '':
break;
payload = struct.pack('!H', pktno) + data
#print 'zhifeng: ', 'struct.pack(\'!H\', pktno) = ',help(struct.pack) #raw_input('press any key to continue')
send_pkt(payload) n += len(payload) #print 'zhifeng: ', n sys.stderr.write('.')
if options.discontinuous and pktno % 5 == 4: time.sleep(1)
pktno += 1
print 'zhifeng: pktno = ', pktno, 'n = ', n
#zhifeng on 070705: must add below 'raw_input' to delay eof!!! otherwise, Thread fg may have not take out all the messages in the quequ!
raw_input('zhifeng on 070705: press any key to continue') send_pkt(eof=True)
fg.wait() # wait for it to finish if __name__ == '__main__':
try: main()
except KeyboardInterrupt: pass
EK-D Ses-rx.py
#!/usr/bin/env python
from gnuradio import gr, gru, modulation_utils from gnuradio import usrp
from gnuradio import eng_notation
from gnuradio.eng_option import eng_option from optparse import OptionParser
import random import struct import sys # from current dir
from receive_path import receive_path import fusb_options
#import os #print os.getpid()
#raw_input('Attach and press enter: ') class my_graph(gr.flow_graph):
def __init__(self, demod_class, rx_callback, options): gr.flow_graph.__init__(self)
self.rxpath = receive_path(self, demod_class, rx_callback, options) #/////////////////////////////////////////////////////////////////// # main #/////////////////////////////////////////////////////////////////// global n_rcvd, n_right def main(): global n_rcvd, n_right n_rcvd = 0 n_right = 0
def rx_callback(ok, payload): global n_rcvd, n_right
(pktno,) = struct.unpack('!H', payload[0:2]) n_rcvd += 1
if ok:
n_right += 1
print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % ( ok, pktno, n_rcvd, n_right)
#add by Zhifeng on 070927 #print payload[2:]
demods = modulation_utils.type_1_demods() # Create Options Parser:
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=demods.keys(), default='gmsk',
help="Select modulation from: %s [default=%%default]" % (', '.join(demods.keys()),))
receive_path.add_options(parser, expert_grp) for mod in demods.values():
mod.add_options(expert_grp) fusb_options.add_options(expert_grp) (options, args) = parser.parse_args () if len(args) != 0:
parser.print_help(sys.stderr) sys.exit(1)
if options.rx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr)
sys.exit(1) # build the graph
fg = my_graph(demods[options.modulation], rx_callback, options) r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: Failed to enable realtime scheduling." fg.start() # start flow graph
fg.wait() # wait for it to finish if __name__ == '__main__': try:
main()
except KeyboardInterrupt: pass
EK-E Mp3.py
#!/usr/bin/env python
from gnuradio import gr, eng_notation from gnuradio import usrp
from gnuradio import audio from gnuradio import blks2
from gnuradio.eng_option import eng_option from optparse import OptionParser
from usrpm import usrp_dbid
import math, re, sys, thread, time, tempfile, os, random def mp3toraw(filename,outputfile):
print("nice -n 19 sox \"%s\" -r 32000 -t raw -f -L -c 1 %s\n" % (filename,outputfile)) os.system("nice -n 19 sox \"%s\" -r 32000 -t raw -f -L -c 1 %s" % (filename,outputfile))
# Read in .pls format (can be made e.g., using beep-media-player)
def read_playlist(fname): input = open(fname, 'r') playlist=[] #[playlist] l = input.readline() # NumberOfEntries l = input.readline() nentries = int(re.findall("NumberOfEntries=([0-9]+)",l)[0]) print "Number of items in list %d\n" % nentries
i = 1 while l: l=input.readline() filepath = re.findall("File[0-9]+=(.*)$",l) if filepath: print filepath[0] playlist.append(filepath[0]) i = i + 1 input.close() return(playlist)
## just create a standard tempfn (sox will create the file, so remove one made by system)
def mktempfn(): tf = tempfile.mkstemp(".raw") outputfile = tf[1] os.close(tf[0]) os.remove(tf[1]) return(outputfile) class wfm_tx: def __init__(self):
parser = OptionParser (option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None, help="select USRP Tx side A or B")
help="set Tx frequency to FREQ (default 90e6)", metavar="FREQ") parser.add_option("-l","--playlist", action="store", default=None,
help="MP3 playlist containing files to air.")
parser.add_option("-r","--randomize", action="store_true", default=False, help="Randomize playlist...")
parser.add_option("","--debug", action="store_true", default=False, help="Launch Tx debugger")
(options, args) = parser.parse_args ()
if len(args) != 0: parser.print_help() sys.exit(1)
if options.playlist == None: print "No playlist specified\n" sys.exit()
# parse playlist
playlist = read_playlist(options.playlist)
# setup IQ rate to 320kS/s and audio rate to 32kS/s self.u = usrp.sink_c()
self.dac_rate = self.u.dac_rate() # 128 MS/s self.usrp_interp = 400
self.u.set_interp_rate(self.usrp_interp)
self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s self.sw_interp = 10
self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s # determine the daughterboard subdevice we're using if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u) m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec) self.u.set_mux(m)
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec) print "Using TX d'board %s" % (self.subdev.side_and_name(),)
self.subdev.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
if not self.set_freq(options.freq): freq_range = self.subdev.freq_range()
print "Failed to set frequency to %s. Daughterboard supports %s to %s" % ( eng_notation.num_to_str(options.freq),
eng_notation.num_to_str(freq_range[0]), eng_notation.num_to_str(freq_range[1])) raise SystemExit
self.subdev.set_enable(True) # enable transmitter print "TX freq %1.2f MHz\n" % (options.freq/1e6)
gain = gr.multiply_const_cc(4000.0)
# loop through playlist if options.randomize:
i = random.randint(0,len(playlist)-1) else:
i = 0
self.fg = gr.top_block()
fmtx = blks2.wfm_tx(self.audio_rate, self.usrp_rate,max_dev=75e3, tau=75e-6) while 1:
outputfile = mktempfn()
# write raw sound to named pipe in background
# sleep until we are sure there is something to play time.sleep(3)
print "File size %d\n" % int(os.stat(outputfile)[6])
src = gr.file_source(gr.sizeof_float, outputfile, False)
# connect blocks
self.fg.connect(src, fmtx, gain, self.u)
print "Starting to play\n" self.fg.run()
print "Done..."
# stop and wait to finish self.fg.stop()
self.fg.wait()
self.fg.disconnect(src, fmtx, gain, self.u) os.remove(outputfile)
# hack, we should get pid and kill sox only if necessary. os.system("killall sox") if options.randomize: i = random.randint(0,len(playlist)-1) else: i = (i + 1) % len(playlist) def set_freq(self, target_freq):
r = self.u.tune(self.subdev.which(), self.subdev, target_freq) if r:
print "r.baseband_freq =", eng_notation.num_to_str(r.baseband_freq) print "r.dxc_freq =", eng_notation.num_to_str(r.dxc_freq)
print "r.residual_freq =", eng_notation.num_to_str(r.residual_freq) print "r.inverted =", r.inverted
return True return False
if __name__ == '__main__': wfm_tx()
EK-F 64 QAM
#!/usr/bin/env python
from gnuradio import gr, gru, modulation_utils from math import pi, sqrt import qam import cmath from pprint import pprint
# default values (used in __init__ and add_options) _def_samples_per_symbol = 2 _def_excess_bw = 0.35 _def_gray_code = True _def_verbose = False _def_log = False
_def_costas_alpha = None _def_gain_mu = 0.03 _def_mu = 0.05 _def_omega_relative_limit = 0.005 # ///////////////////////////////////////////////////////////////////////////// # QAM64 modulator # ///////////////////////////////////////////////////////////////////////////// class qam64_mod(gr.hier_block2): def __init__(self, samples_per_symbol=_def_samples_per_symbol, excess_bw=_def_excess_bw, gray_code=_def_gray_code, verbose=_def_verbose, log=_def_log): gr.hier_block2.__init__(self, "qam64_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw self._gray_code = gray_code
raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol) ntaps = 11 * samples_per_symbol
arity = pow(2, self.bits_per_symbol()) # turn bytes into k-bit vectors self.bytes2chunks = \ gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST) if self._gray_code: self.symbol_mapper = gr.map_bb(qam.binary_to_gray[arity]) else: self.symbol_mapper = gr.map_bb(qam.binary_to_ungray[arity]) self.diffenc = gr.diff_encoder_bb(arity) rot = 1.0
print "constellation with %d arity" % arity
rotated_const = map(lambda pt: pt * rot, qam.constellation[arity]) self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const) # pulse shaping filter
self.rrc_taps = gr.firdes.root_raised_cosine(
self._samples_per_symbol, # gain (sps since we're interpolating by sps) self._samples_per_symbol, # sampling rate
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor) ntaps)
self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps) if verbose: self._print_verbage() if log: self._setup_logging() # Connect
self.connect(self, self.bytes2chunks, self.symbol_mapper, self.diffenc, self.chunks2symbols, self.rrc_filter, self)
def samples_per_symbol(self): return self._samples_per_symbol
def bits_per_symbol(self=None): # staticmethod that's also callable on an instance return 6
bits_per_symbol = staticmethod(bits_per_symbol) # make it a static method. RTFM def _print_verbage(self):
print "bits per symbol = %d" % self.bits_per_symbol() print "Gray code = %s" % self._gray_code
print "RRS roll-off factor = %f" % self._excess_bw def _setup_logging(self):
print "Modulation logging turned on." self.connect(self.bytes2chunks, gr.file_sink(gr.sizeof_char, "bytes2chunks.dat")) self.connect(self.symbol_mapper, gr.file_sink(gr.sizeof_char, "graycoder.dat")) self.connect(self.diffenc, gr.file_sink(gr.sizeof_char, "diffenc.dat")) self.connect(self.chunks2symbols, gr.file_sink(gr.sizeof_gr_complex, "chunks2symbols.dat")) self.connect(self.rrc_filter, gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat")) def add_options(parser): """
Adds QAM modulation-specific options to the standard parser """
parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw, help="set RRC excess bandwith factor [default=%default] (PSK)") parser.add_option("", "--no-gray-code", dest="gray_code",
action="store_false", default=_def_gray_code, help="disable gray coding on modulated bits (PSK)") add_options=staticmethod(add_options)
def extract_kwargs_from_options(options): """
Given command line options, create dictionary suitable for passing to __init__ """
return modulation_utils.extract_kwargs_from_options(qam64_mod.__init__, ('self',), options)
# ///////////////////////////////////////////////////////////////////////////// # QAM64 demodulator # # ///////////////////////////////////////////////////////////////////////////// class qam64_demod(gr.hier_block2): def __init__(self, samples_per_symbol=_def_samples_per_symbol, excess_bw=_def_excess_bw, costas_alpha=_def_costas_alpha, gain_mu=_def_gain_mu, mu=_def_mu, omega_relative_limit=_def_omega_relative_limit, gray_code=_def_gray_code, verbose=_def_verbose, log=_def_log): gr.hier_block2.__init__(self, "qam64_demod",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(1, 1, gr.sizeof_char)) # Output signature # do this
pass
def bits_per_symbol(self=None): # staticmethod that's also callable on an instance return 6
bits_per_symbol = staticmethod(bits_per_symbol) # make it a static method. RTFM #
# Add these to the mod/demod registry #
# NOT READY TO BE USED YET -- ENABLE AT YOUR OWN RISK #modulation_utils.add_type_1_mod('qam64', qam64_mod)
#modulation_utils.add_type_1_demod('qam16', qam16_demod)
KİİSEL YAYIN VE ESERLER
1.
Didem ÇOLAK ARSLAN, Serpil
İLHAN, Hasan Dinçer, “Bili
şsel Radyo”,
ELECO'2008 Elektronik-Elektronik Bilgisayar Mühendisli
ği Sempozyumu,
ÖZGEÇMİ
1983 yılında Ankara’da doğdu. İlk, orta ve lise öğrenimini İzmit’te tamamladı. 2001 yılında girdiği Kocaeli Üniversitesi Mühendislik Fakültesi Elektronik ve Haberleşme Mühendisliği Bölümü’nden 2005 yılında mezun oldu. 2005 yılından beri Kocaeli Üniversitesi Mühendislik Fakültesi Elektronik ve Haberleşme Mühendisliği Bölümü’nde Yüksek Lisans’a devam etmektedir. 2006 yılından beri Nortel Netaş’ ta yazılım tasarım mühendisi olarak çalışmaktadır.