Hello,
thank you very much for answering me.
Selon Paul Mathews <[EMAIL PROTECTED]>:
> > I know very little about RFID, but I can make these observations on
>
> > how I would probably perform a naive demodulation of this signal.
>
> > 1. Tune the USRP to your carrier frequency and bring your signal
> > down to baseband (centered around DC).
> > 2. Choose an appropriate number of samples per symbol or bit (I'd
>
> > arbitrarily choose 6 .. or 8).
> > 3. Filter the incoming signal to some appropriate spectral mask.
> > 4. Find the magnitude (or even power since it saves a sqrt) of the
> > complex vector.
> > 5. Develop some algorithm which accounts for frequency offset/tracking.
>
> > 6. Perform hard decisions from the soft decisions you make from the
> > algorithm developed in step (5).
>
>
> Marco,
> Are you trying to decode the reader transmission, or the tag reply? You may
> be able to use a matched filter as a first step to clean up the signal
> before
> demodulating. I'm not really sure what 13.56 MHz RFID signals look like, but
> that
>
> helps a lot at 915 MHz.
>
> Regardless, I think step 3 is the key to get you started. You don't want to
> just
> throw out the I or Q channel. You probably want to use the complex_to_mag
> block,
> and then the signal will look like what you expect.
>
> michael
>
> To try to answer Marco's original question about I/Q directly: the phase
> info available from I/Q samples is not directly useful for RFID ASK signals.
> However, the calculated magnitude provides slightly better SNR than would
> samples of magnitude alone.
>
> I've done a lot of work with 13 MHz RFID. Most common form of modulation is
> Amplitude Shift Keying, a form of AM, with the data stream Manchester
> encoded.
> http://en.wikipedia.org/wiki/Manchester_coding
> A good example of channel filtering and AM demodulation using complex_to_mag
> is usrp_am_mw_rcv.py. That example is setup for AM broadcast, so you'll want
> to widen the channel filter BW out to accomodate the baud rate you're using,
> and, you can eliminate the audio filtering and sink code.
I am trying to understand how to modify usrp_am_mw_rcv.py code:
I have eliminated everything inherent the volume and the audio and I have
modified the parameters in that way:
16 as usrp_decim
1 as chanfilt_decim
chan_filt_coeffs:
400e3 as passband cutoff
410e3 as stopband cutoff
1.0 as passband ripple
60 as stopband attenuation
Is it correct?
(To be more clear I have attached the .py modified file)
I think I'll still have some troubles with the GUI, but so far this is the
message error I got:
[EMAIL PROTECTED]:~/Desktop# ./usrp_am_mw_rcv_002.py -R B -f 13560000
Using RX d'board B: LF Rx
>>> gr_fir_ccf: using SSE
** (python:6937): WARNING **: IPP request failed with status 1030
FYI: No Powermate or Contour Knob found
Traceback (most recent call last):
File "./usrp_am_mw_rcv_002.py", line 335, in <module>
app = stdgui2.stdapp (wfm_rx_block, "USRP Broadcast AM MW RX modified")
File "/usr/local/lib/python2.5/site-packages/gnuradio/wxgui/stdgui2.py", line
36, in __init__
wx.App.__init__ (self, redirect=False)
File "/usr/lib/python2.5/site-packages/wx-2.8-gtk2-unicode/wx/_core.py", line
7935, in __init__
self._BootstrapApp()
File "/usr/lib/python2.5/site-packages/wx-2.8-gtk2-unicode/wx/_core.py", line
7509, in _BootstrapApp
return _core_.PyApp__BootstrapApp(*args, **kwargs)
File "/usr/local/lib/python2.5/site-packages/gnuradio/wxgui/stdgui2.py", line
39, in OnInit
frame = stdframe (self.top_block_maker, self.title, self._nstatus)
File "/usr/local/lib/python2.5/site-packages/gnuradio/wxgui/stdgui2.py", line
60, in __init__
self.panel = stdpanel (self, self, top_block_maker)
File "/usr/local/lib/python2.5/site-packages/gnuradio/wxgui/stdgui2.py", line
86, in __init__
self.top_block.start ()
File "/usr/local/lib/python2.5/site-packages/gnuradio/gr/top_block.py", line
45, in start
self._tb.start()
File
"/usr/local/lib/python2.5/site-packages/gnuradio/gr/gnuradio_swig_py_runtime.py",
line 1461, in start
return _gnuradio_swig_py_runtime.gr_top_block_sptr_start(*args)
RuntimeError: complex_to_mag(4): insufficient connected output ports (1 needed,
0 connected)
> The demodulated
> output is the 'envelope' of the signal, with an offset the depends on the
> percentage of modulation achieved. The RFID reader in Marco's case achieves
> 100% modulation, so the offset will be 50% of peak level, like this (fixed
> font spacing req'd):
> ___ ___ ___
> | | | | | |
> 0 ___| |___| |___| |___
>
> RFID tags typically achieve much lower modulation percentages, depending on
> coupling with the reader, like this:
>
>
> ___ ___ ___
> | |___| |__| |
> 0 ___| |___
>
> In either case, you can threshold the data at some value less than the
> average peak to do a crude conversion from envelope to bits. In turn, you
> can examine the bitstream to locate bit transitions. The bit stream can then
> be decoded.
Here I have another question: at the moment I am trying to do that in Matlab
because of my so much inexperience in programming with Gnuradio. My problem is
to recognize the length of the bits... Once I have converted the I/Q samples in
magnitude, do I have to work in time domain or in the samples domain? (to be
more clear, counting the microseconds or counting the number of the samples to
identify a bit period?)
> There are better ways, e.g., using matched filters, to identify
> Manchester codes directly from the envelope data, but this should get you
> started.
> Paul Mathews
>
>
>
Thank you very much,
Marco
#!/usr/bin/env python
#
# Copyright 2005,2006,2007 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING. If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#
from gnuradio import gr, gru, eng_notation, optfir
from gnuradio import audio
from gnuradio import usrp
from gnuradio import blks2
from gnuradio.eng_option import eng_option
from gnuradio.wxgui import slider, powermate
from gnuradio.wxgui import stdgui2, fftsink2, form
from optparse import OptionParser
from usrpm import usrp_dbid
import sys
import math
import wx
def pick_subdevice(u):
"""
The user didn't specify a subdevice on the command line.
Try for one of these, in order: BASIC_RX,TV_RX, BASIC_RX, whatever is on side A.
@return a subdev_spec
"""
return usrp.pick_subdev(u, (usrp_dbid.BASIC_RX,
usrp_dbid.LF_RX,
usrp_dbid.TV_RX,
usrp_dbid.TV_RX_REV_2,
usrp_dbid.TV_RX_REV_3))
class wfm_rx_block (stdgui2.std_top_block):
def __init__(self,frame,panel,vbox,argv):
stdgui2.std_top_block.__init__ (self,frame,panel,vbox,argv)
parser=OptionParser(option_class=eng_option)
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None,
help="select USRP Rx side A or B (default=A)")
parser.add_option("-f", "--freq", type="eng_float", default=1008.0e3,
help="set frequency to FREQ", metavar="FREQ")
parser.add_option("-I", "--use-if-freq", action="store_true", default=False,
help="use intermediate freq (compensates DC problems in quadrature boards)" )
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is maximum)")
#parser.add_option("-V", "--volume", type="eng_float", default=None,
# help="set volume (default is midpoint)")
#parser.add_option("-O", "--audio-output", type="string", default="",
# help="pcm device name. E.g., hw:0,0 or surround51 or /dev/dsp")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
self.frame = frame
self.panel = panel
self.use_IF=options.use_if_freq
if self.use_IF:
self.IF_freq=64000.0
else:
self.IF_freq=0.0
#self.vol = 0
self.state = "FREQ"
self.freq = 0
# build graph
#TODO: add an AGC after the channel filter and before the AM_demod
self.u = usrp.source_c() # usrp is data source
adc_rate = self.u.adc_rate() # 64 MS/s
usrp_decim = 16
self.u.set_decim_rate(usrp_decim)
usrp_rate = adc_rate / usrp_decim # 4Ms/s
chanfilt_decim = 1
demod_rate = usrp_rate / chanfilt_decim # 64 kHz
#audio_decimation = 2
#audio_rate = demod_rate / audio_decimation # 32 kHz
if options.rx_subdev_spec is None:
options.rx_subdev_spec = pick_subdevice(self.u)
self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.subdev.side_and_name(),)
# filter to isolate the PCD --> PICC comunication
chan_filt_coeffs = optfir.low_pass (1, # gain
usrp_rate, # sampling rate
400e3, # passband cutoff
410e3, # stopband cutoff
1.0, # passband ripple
60) # stopband attenuation
#print len(chan_filt_coeffs)
self.chan_filt = gr.fir_filter_ccf (chanfilt_decim, chan_filt_coeffs)
if self.use_IF:
# Turn If to baseband and filter.
self.chan_filt = gr.freq_xlating_fir_filter_ccf (chanfilt_decim, chan_filt_coeffs, self.IF_freq, usrp_rate)
else:
self.chan_filt = gr.fir_filter_ccf (chanfilt_decim, chan_filt_coeffs)
self.am_demod = gr.complex_to_mag()
#self.volume_control = gr.multiply_const_ff(self.vol)
#audio_filt_coeffs = optfir.low_pass (1, # gain
# demod_rate, # sampling rate
# 8e3, # passband cutoff
# 10e3, # stopband cutoff
# 0.1, # passband ripple
# 60) # stopband attenuation
#self.audio_filt=gr.fir_filter_fff(audio_decimation,audio_filt_coeffs)
# sound card as final sink
#audio_sink = audio.sink (int (audio_rate),
# options.audio_output,
# False) # ok_to_block
# now wire it all together
#self.connect (self.u, self.chan_filt, self.am_demod, self.audio_filt, self.volume_control, audio_sink)
self.connect (self.u, self.chan_filt, self.am_demod)
#self._build_gui(vbox, usrp_rate, demod_rate, audio_rate)
self._build_gui(vbox, usrp_rate, demod_rate)
if options.gain is None:
g = self.subdev.gain_range()
if True:
# if no gain was specified, use the maximum gain available
# (usefull for Basic_RX which is relatively deaf and the most probable board to be used for AM)
# TODO: check db type to decide on default gain.
options.gain = float(g[1])
else:
# if no gain was specified, use the mid-point in dB
options.gain = float(g[0]+g[1])/2
#if options.volume is None:
# g = self.volume_range()
# options.volume = float(g[0]*3+g[1])/4
if abs(options.freq) < 1e3:
options.freq *= 1e3
# set initial values
self.set_gain(options.gain)
#self.set_vol(options.volume)
if not(self.set_freq(options.freq)):
self._set_status_msg("Failed to set initial frequency")
def _set_status_msg(self, msg, which=0):
self.frame.GetStatusBar().SetStatusText(msg, which)
#def _build_gui(self, vbox, usrp_rate, demod_rate, audio_rate):
def _build_gui(self, vbox, usrp_rate, demod_rate):
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
if 1:
self.src_fft = fftsink2.fft_sink_c(self.panel, title="Data from USRP",
fft_size=1024, sample_rate=usrp_rate,
ref_scale=32768.0, ref_level=0.0, y_divs=12)
self.connect (self.u, self.src_fft)
vbox.Add (self.src_fft.win, 4, wx.EXPAND)
if 0:
self.post_filt_fft = fftsink2.fft_sink_c(self.panel, title="Post Channel filter",
fft_size=1024, sample_rate=demod_rate)
self.connect (self.chan_filt, self.post_filt_fft)
vbox.Add (self.post_filt_fft.win, 4, wx.EXPAND)
if 0:
post_demod_fft = fftsink2.fft_sink_f(self.panel, title="Post Demod",
fft_size=1024, sample_rate=demod_rate,
y_per_div=10, ref_level=0)
self.connect (self.am_demod, post_demod_fft)
vbox.Add (post_demod_fft.win, 4, wx.EXPAND)
#if 1:
# audio_fft = fftsink2.fft_sink_f(self.panel, title="Audio",
# fft_size=512,
# sample_rate=audio_rate,
# y_per_div=10, ref_level=20)
# self.connect (self.audio_filt, audio_fft)
# vbox.Add (audio_fft.win, 4, wx.EXPAND)
# control area form at bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5,0), 0)
myform['freq'] = form.float_field(
parent=self.panel, sizer=hbox, label="Freq", weight=1,
callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))
hbox.Add((5,0), 0)
myform['freq_slider'] = \
form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
#range=(520.0e3, 1611.0e3, 1.0e3),
range=(520.0e3, 1611.0e3, 1.0e3),
callback=self.set_freq)
hbox.Add((5,0), 0)
vbox.Add(hbox, 0, wx.EXPAND)
hbox = wx.BoxSizer(wx.HORIZONTAL)
# hbox.Add((5,0), 0)
# myform['volume'] = \
# form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
# weight=3, range=self.volume_range(),
# callback=self.set_vol)
# hbox.Add((5,0), 1)
hbox.Add((5,0), 0)
myform['gain'] = \
form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
weight=3, range=self.subdev.gain_range(),
callback=self.set_gain)
hbox.Add((5,0), 0)
vbox.Add(hbox, 0, wx.EXPAND)
try:
self.knob = powermate.powermate(self.frame)
self.rot = 0
# powermate.EVT_POWERMATE_ROTATE (self.frame, self.on_rotate)
powermate.EVT_POWERMATE_BUTTON (self.frame, self.on_button)
except:
print "FYI: No Powermate or Contour Knob found"
#def on_rotate (self, event):
# self.rot += event.delta
# if (self.state == "FREQ"):
# if self.rot >= 3:
# self.set_freq(self.freq + .1e6)
# self.rot -= 3
# elif self.rot <=-3:
# self.set_freq(self.freq - .1e6)
# self.rot += 3
# else:
# step = self.volume_range()[2]
# if self.rot >= 3:
# self.set_vol(self.vol + step)
# self.rot -= 3
# elif self.rot <=-3:
# self.set_vol(self.vol - step)
# self.rot += 3
def on_button (self, event):
if event.value == 0: # button up
return
self.rot = 0
if self.state == "FREQ":
self.state = "VOL"
else:
self.state = "FREQ"
self.update_status_bar ()
#def set_vol (self, vol):
# g = self.volume_range()
# self.vol = max(g[0], min(g[1], vol))
# self.volume_control.set_k(10**(self.vol/10))
# self.myform['volume'].set_value(self.vol)
# self.update_status_bar ()
def set_freq(self, target_freq):
"""
Set the center frequency we're interested in.
@param target_freq: frequency in Hz
@rypte: bool
Tuning is a two step process. First we ask the front-end to
tune as close to the desired frequency as it can. Then we use
the result of that operation and our target_frequency to
determine the value for the digital down converter.
"""
r = usrp.tune(self.u, 0, self.subdev, target_freq + self.IF_freq)
#TODO: check if db is inverting the spectrum or not to decide if we should do + self.IF_freq or - self.IF_freq
if r:
self.freq = target_freq
self.myform['freq'].set_value(target_freq) # update displayed value
self.myform['freq_slider'].set_value(target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.subdev.set_gain(gain)
def update_status_bar (self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
#msg = "Setting:%s" % (self.state)
#self._set_status_msg(msg, 1)
#self._set_status_msg(msg)
try:
self.src_fft.set_baseband_freq(self.freq)
except:
None
#def volume_range(self):
# return (-40.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp (wfm_rx_block, "USRP Broadcast AM MW RX modified")
app.MainLoop ()
_______________________________________________
Discuss-gnuradio mailing list
[email protected]
http://lists.gnu.org/mailman/listinfo/discuss-gnuradio
