Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
1 contributor

Users who have contributed to this file

822 lines (643 sloc) 23.8 KB
"""
Test lab for FM decoding algorithms.
Use as follows:
>>> graw = pyfm.lazyRawSamples('rtlsdr.dat', 1000000)
>>> gtune = pyfm.freqShiftIQ(graw, 0.25)
>>> bfir = scipy.signal.firwin(20, 0.2, window='nuttall')
>>> gfilt = pyfm.firFilter(gtune, bfir)
>>> gbase = pyfm.quadratureDetector(gfilt, fs=1.0e6)
>>> fs,qs = pyfm.spectrum(gbase, fs=1.0e6)
"""
import sys
import datetime
import types
import numpy
import numpy.fft
import numpy.linalg
import numpy.random
import scipy.signal
def sincw(n):
"""Return Sinc or Lanczos window of length n."""
w = numpy.zeros(n)
for i in xrange(n):
if 2 * i == n + 1:
w[i] = 1.0
else:
t = 2 * i / float(n+1) - 1
w[i] = numpy.sin(numpy.pi * t) / (numpy.pi * t)
return w
def readRawSamples(fname):
"""Read raw sample file from rtl_sdr."""
d = numpy.fromfile(fname, dtype=numpy.uint8)
d = d.astype(numpy.float64)
d = (d - 128) / 128.0
return d[::2] + 1j * d[1::2]
def lazyRawSamples(fname, blocklen):
"""Return generator over blocks of raw samples."""
f = file(fname, 'rb')
while 1:
d = f.read(2 * blocklen)
if len(d) < 2 * blocklen:
break
d = numpy.fromstring(d, dtype=numpy.uint8)
d = d.astype(numpy.float64)
d = (d - 128) / 128.0
yield d[::2] + 1j * d[1::2]
def freqShiftIQ(d, freqshift):
"""Shift frequency by multiplication with complex phasor."""
def g(d, freqshift):
p = 0
for b in d:
n = len(b)
w = numpy.exp((numpy.arange(n) + p) * (2j * numpy.pi * freqshift))
p += n
yield b * w
if isinstance(d, types.GeneratorType):
return g(d, freqshift)
else:
n = len(d)
w = numpy.exp(numpy.arange(n) * (2j * numpy.pi * freqshift))
return d * w
def firFilter(d, coeff):
"""Apply FIR filter to sample stream."""
# lazy version
def g(d, coeff):
prev = None
for b in d:
if prev is None:
yield scipy.signal.lfilter(coeff, 1, b)
prev = b
else:
k = min(len(prev), len(coeff))
x = numpy.concatenate((prev[-k:], b))
y = scipy.signal.lfilter(coeff, 1, x)
yield y[k:]
if len(coeff) > len(b):
prev = x
else:
prev = b
if isinstance(d, types.GeneratorType):
return g(d, coeff)
else:
return scipy.signal.lfilter(coeff, 1, d)
def quadratureDetector(d, fs):
"""FM frequency detector based on quadrature demodulation.
Return an array of real-valued numbers, representing frequencies in Hz."""
k = fs / (2 * numpy.pi)
# lazy version
def g(d):
prev = None
for b in d:
if prev is not None:
x = numpy.concatenate((prev[1:], b[:1]))
yield numpy.angle(x * prev.conj()) * k
prev = b
yield numpy.angle(prev[1:] * prev[:-1].conj()) * k
if isinstance(d, types.GeneratorType):
return g(d)
else:
return numpy.angle(d[1:] * d[:-1].conj()) * k
def modulateFm(sig, fs, fcenter=0):
"""Create an FM modulated IQ signal.
sig :: modulation signal, values in Hz
fs :: sample rate in Hz
fcenter :: center frequency in Hz
"""
return numpy.exp(2j * numpy.pi * (sig + fcenter).cumsum() / fs)
def spectrum(d, fs=1, nfft=None, sortfreq=False):
"""Calculate Welch-style power spectral density.
fs :: sample rate, default to 1
nfft :: FFT length, default to block length
sortfreq :: True to put negative freqs in front of positive freqs
Use Hann window with 50% overlap.
Return (freq, Pxx)."""
if not isinstance(d, types.GeneratorType):
d = [ d ]
prev = None
if nfft is not None:
assert nfft > 0
w = numpy.hanning(nfft)
q = numpy.zeros(nfft)
pos = 0
i = 0
for b in d:
if nfft is None:
nfft = len(b)
assert nfft > 0
w = numpy.hanning(nfft)
q = numpy.zeros(nfft)
while pos + nfft <= len(b):
if pos < 0:
t = numpy.concatenate((prev[pos:], b[:pos+nfft]))
else:
t = b[pos:pos+nfft]
t *= w
tq = numpy.fft.fft(t)
tq *= numpy.conj(tq)
q += numpy.real(tq)
del t
del tq
pos += (nfft+(i%2)) // 2
i += 1
pos -= len(b)
if pos + len(b) > 0:
prev = b
else:
prev = numpy.concatenate((prev[pos+len(b):], b))
if i > 0:
q /= (i * numpy.sum(numpy.square(w)) * fs)
f = numpy.arange(nfft) * (fs / float(nfft))
f[nfft//2:] -= fs
if sortfreq:
f = numpy.concatenate((f[nfft//2:], f[:nfft//2]))
q = numpy.concatenate((q[nfft//2:], q[:nfft//2]))
return f, q
def pll(d, centerfreq, bandwidth):
"""Simulate the stereo pilot PLL."""
minfreq = (centerfreq - bandwidth) * 2 * numpy.pi
maxfreq = (centerfreq + bandwidth) * 2 * numpy.pi
w = bandwidth * 2 * numpy.pi
phasor_a = numpy.poly([ numpy.exp(-1.146*w), numpy.exp(-5.331*w) ])
phasor_b = numpy.array([ sum(phasor_a) ])
loopfilter_b = numpy.poly([ numpy.exp(-0.1153*w) ])
loopfilter_b *= 0.62 * w
n = len(d)
y = numpy.zeros(n)
phasei = numpy.zeros(n)
phaseq = numpy.zeros(n)
phaseerr = numpy.zeros(n)
freq = numpy.zeros(n)
phase = numpy.zeros(n)
freq[0] = centerfreq * 2 * numpy.pi
phasor_i1 = phasor_i2 = 0
phasor_q1 = phasor_q2 = 0
loopfilter_x1 = 0
for i in xrange(n):
psin = numpy.sin(phase[i])
pcos = numpy.cos(phase[i])
y[i] = pcos
pi = pcos * d[i]
pq = psin * d[i]
pi = phasor_b[0] * pi - phasor_a[1] * phasor_i1 - phasor_a[2] * phasor_i2
pq = phasor_b[0] * pq - phasor_a[1] * phasor_q1 - phasor_a[2] * phasor_q2
phasor_i2 = phasor_i1
phasor_i1 = pi
phasor_q2 = phasor_q1
phasor_q1 = pq
phasei[i] = pi
phaseq[i] = pq
if pi > abs(pq):
perr = pq / pi
elif pq > 0:
perr = 1
else:
perr = -1
phaseerr[i] = perr
dfreq = loopfilter_b[0] * perr + loopfilter_b[1] * loopfilter_x1
loopfilter_x1 = perr
if i + 1 < n:
freq[i+1] = min(maxfreq, max(minfreq, freq[i] - dfreq))
p = phase[i] + freq[i+1]
if p > 2 * numpy.pi: p -= 2 * numpy.pi
if p < -2 * numpy.pi: p += 2 * numpy.pi
phase[i+1] = p
return y, phasei, phaseq, phaseerr, freq, phase
def pilotLevel(d, fs, freqshift, nfft=None, bw=150.0e3):
"""Calculate level of the 19 kHz pilot vs noise floor in the guard band.
d :: block of raw I/Q samples or lazy I/Q sample stream
fs :: sample frequency in Hz
nfft :: FFT length
freqshift :: frequency offset in Hz
bw :: half-bandwidth of IF signal in Hz
Return (pilot_power, guard_floor, noise)
where pilot_power is the power of the pilot tone in dB
guard_floor is the noise floor in the guard band in dB/Hz
noise is guard_floor - pilot_power in dB/Hz
"""
# Shift frequency
if freqshift != 0:
d = freqShiftIQ(d, freqshift / float(fs))
# Filter
b = scipy.signal.firwin(31, 2.0 * bw / fs, window='nuttall')
d = firFilter(d, b)
# Demodulate FM.
d = quadratureDetector(d, fs)
# Power spectral density.
f, q = spectrum(d, fs=fs, nfft=nfft, sortfreq=False)
# Locate 19 kHz bin.
k19 = int(19.0e3 * len(q) / fs)
kw = 5 + int(100.0 * len(q) / fs)
k19 = k19 - kw + numpy.argmax(q[k19-kw:k19+kw])
# Calculate pilot power.
p19 = numpy.sum(q[k19-1:k19+2]) * fs * 1.5 / len(q)
# Calculate noise floor in guard band.
k17 = int(17.0e3 * len(q) / fs)
k18 = int(18.0e3 * len(q) / fs)
guard = numpy.mean(q[k17:k18])
p19db = 10 * numpy.log10(p19)
guarddb = 10 * numpy.log10(guard)
return (p19db, guarddb, guarddb - p19db)
def modulateAndReconstruct(sigfreq, sigampl, nsampl, fs, noisebw=None, ifbw=None, ifnoise=0, ifdownsamp=1):
"""Create a pure sine wave, modulate to FM, add noise, filter, demodulate.
sigfreq :: frequency of sine wave in Hz
sigampl :: amplitude of sine wave in Hz (carrier swing)
nsampl :: number of samples
fs :: sample rate in Hz
noisebw :: calculate noise after demodulation over this bandwidth
ifbw :: IF filter bandwidth in Hz, or None for no filtering
ifnoise :: IF noise level
ifdownsamp :: downsample factor before demodulation
Return (ampl, phase, noise)
where ampl is the amplitude of the reconstructed sine wave (~ sigampl)
phase is the phase shift after reconstruction
noise is the standard deviation of noise in the reconstructed signal
"""
# Make sine wave.
sig0 = sigampl * numpy.sin(2*numpy.pi*sigfreq/fs * numpy.arange(nsampl))
# Modulate to IF.
fm = modulateFm(sig0, fs=fs, fcenter=0)
# Add noise.
if ifnoise:
fm += numpy.sqrt(0.5) * numpy.random.normal(0, ifnoise, nsampl)
fm += 1j * numpy.sqrt(0.5) * numpy.random.normal(0, ifnoise, nsampl)
# Filter IF.
if ifbw is not None:
b = scipy.signal.firwin(101, 2.0 * ifbw / fs, window='nuttall')
fm = scipy.signal.lfilter(b, 1, fm)
fm = fm[61:]
# Downsample IF.
fs1 = fs
if ifdownsamp != 1:
fm = fm[::ifdownsamp]
fs1 = fs / ifdownsamp
# Demodulate.
sig1 = quadratureDetector(fm, fs=fs1)
# Fit original sine wave.
k = len(sig1)
m = numpy.zeros((k, 3))
m[:,0] = numpy.sin(2*numpy.pi*sigfreq/fs1 * (numpy.arange(k) + nsampl - k))
m[:,1] = numpy.cos(2*numpy.pi*sigfreq/fs1 * (numpy.arange(k) + nsampl - k))
m[:,2] = 1
fit = numpy.linalg.lstsq(m, sig1)
csin, ccos, coffset = fit[0]
del fit
# Calculate amplitude, phase.
ampl1 = numpy.sqrt(csin**2 + ccos**2)
phase1 = numpy.arctan2(-ccos, csin)
# Calculate residual noise.
res1 = sig1 - m[:,0] * csin - m[:,1] * ccos
if noisebw is not None:
b = scipy.signal.firwin(101, 2.0 * noisebw / fs1, window='nuttall')
res1 = scipy.signal.lfilter(b, 1, res1)
noise1 = numpy.sqrt(numpy.mean(res1 ** 2))
return ampl1, phase1, noise1
def rdsDemodulate(d, fs):
"""Demodulate RDS bit stream.
d :: block of baseband samples or lazy baseband sample stream
fs :: sample frequency in Hz
Return (bits, levels)
where bits is a list of RDS data bits
levels is a list of squared RDS carrier amplitudes
"""
# RDS carrier in Hz
carrier = 57000.0
# RDS bit rate in bit/s
bitrate = 1187.5
# Approximate nr of samples per bit.
bitsteps = round(fs / bitrate)
# Prepare FIR coefficients for matched filter.
#
# The filter is a root-raised-cosine with hard cutoff at f = 2/bitrate.
# H(f) = cos(pi * f / (4*bitrate)) if f < 2*bitrate
# H(f) = 0 if f >= 2*bitrate
#
# Impulse response:
# h(t) = ampl * cos(pi*4*bitrate*t) / (1 - 4 * (4*bitrate*t)**2)
#
wlen = int(1.5 * fs / bitrate)
w = numpy.zeros(wlen)
for i in xrange(wlen):
t = (i - 0.5 * (wlen - 1)) * 4.0 * bitrate / fs
if abs(abs(t) - 0.5) < 1.0e-4:
# lim {t->0.5} {cos(pi*t) / (1 - 4*t**2)} = 0.25 * pi
w[i] = 0.25 * numpy.pi - 0.25 * numpy.pi * (abs(t) - 0.5)
else:
w[i] = numpy.cos(numpy.pi * t) / (1 - 4.0 * t * t)
# Use Sinc window to reduce leakage.
w *= sincw(wlen)
# Scale filter such that peak output of filter equals original amplitude.
w /= numpy.sum(w**2)
demod_phase = 0.0
prev_a1 = 0.0
prevb = numpy.array([])
pos = 0
bits = [ ]
levels = [ ]
if not isinstance(d, types.GeneratorType):
d = [ d ]
for b in d:
n = len(b)
# I/Q demodulate with fixed 57 kHz phasor
ps = numpy.arange(n) * (carrier / float(fs)) + demod_phase
dem = b * numpy.exp(-2j * numpy.pi * ps)
demod_phase = (demod_phase + n * carrier / float(fs)) % 1.0
# Merge with remaining data from previous block
prevb = numpy.concatenate((prevb[pos:], dem))
pos = 0
# Detect bits.
while pos + bitsteps + wlen < len(prevb):
# Measure average phase of first impulse of symbol.
a1 = numpy.sum(prevb[pos:pos+wlen] * w)
# Measure average phase of second impulse of symbol.
a2 = numpy.sum(prevb[pos+bitsteps//2:pos+wlen+bitsteps//2] * w)
# Measure average phase in middle of symbol.
a3 = numpy.sum(prevb[pos+bitsteps//4:pos+wlen+bitsteps//4] * w)
# Calculate inner product of first impulse and previous symbol.
sym = a1.real * prev_a1.real + a1.imag * prev_a1.imag
prev_a1 = a1
if sym < 0:
# Consecutive symbols have opposite phase; this is a 1 bit.
bits.append(1)
else:
# Consecutive symbols are in phase; this is a 0 bit.
bits.append(0)
# Calculate inner product of first and second impulse.
a1a2 = a1.real * a2.real + a1.imag * a2.imag
# Calculate inner product of first impulse and middle phasor.
a1a3 = a1.real * a3.real + a1.imag * a3.imag
levels.append(-a1a2)
if a1a2 >= 0:
# First and second impulse are in phase;
# we must be woefully misaligned.
pos += 5 * bitsteps // 8
elif a1a3 > -0.02 * a1a2:
# Middle phasor is in phase with first impulse;
# we are sampling slightly too early.
pos += (102 * bitsteps) // 100
elif a1a3 > -0.01 * a1a2:
pos += (101 * bitsteps) // 100
elif a1a3 < 0.02 * a1a2:
# Middle phasor is opposite to first impulse;
# we are sampling slightly too late.
pos += (98 * bitsteps) // 100
elif a1a3 < 0.01 * a1a2:
pos += (99 * bitsteps) // 100
else:
# Middle phasor is zero; we are sampling just right.
pos += bitsteps
return (bits, levels)
def rdsDecodeBlock(bits, typ):
"""Decode one RDS data block.
bits :: list of 26 bits
typ :: expected block type, "A" or "B" or "C" or "C'" or "D" or "E"
Return (block, ber)
where block is a 16-bit unsigned integer if the block is correctly decoded,
block is None if decoding failed,
ber is 0 if the block is error-free,
ber is 1 if a single-bit error has been corrected,
ber is 2 if decoding failed.
"""
# TODO : there are still problems with bit alignment on weak stations
# TODO : try to pin down the problem
# Offset word for each type of block.
rdsOffsetTable = { "A": 0x0fc, "B": 0x198,
"C": 0x168, "C'": 0x350,
"D": 0x1B4, "E": 0 }
# RDS checkword generator polynomial.
gpoly = 0x5B9
# Convert bits to word.
assert len(bits) == 26
w = 0
for b in bits:
w = 2 * w + b
# Remove block offset.
w ^= rdsOffsetTable[typ]
# Calculate error syndrome.
syn = w
for i in xrange(16):
if syn & (1 << (25 - i)):
syn ^= gpoly << (15 - i)
# Check block.
if syn == 0:
return (w >> 10, 0)
# Error detected; try all single-bit errors.
p = 1
for k in xrange(26):
if p == syn:
# Detected single-bit error in bit k.
w ^= (1 << k)
return (w >> 10, 1)
p <<= 1
if p & 0x400:
p ^= gpoly
# No single-bit error can explain this syndrome.
return (None, 2)
class RdsData(object):
"""Stucture to hold common RDS data fields."""
pi = None
pty = None
tp = None
ta = None
ms = None
af = None
di = None
pin = None
pserv = None
ptyn = None
ptynab = None
rtext = None
rtextab = None
time = None
tmp_afs = None
tmp_aflen = 0
tmp_afmode = 0
ptyTable = [
'None', 'News',
'Current Affairs', 'Information',
'Sport', 'Education',
'Drama', 'Cultures',
'Science', 'Varied Speech',
'Pop Music', 'Rock Music',
'Easy Listening', 'Light Classics M',
'Serious Classics', 'Other Music',
'Weather & Metr', 'Finance',
"Children's Progs", 'Social Affairs',
'Religion', 'Phone In',
'Travel & Touring', 'Leisure & Hobby',
'Jazz Music', 'Country Music',
'National Music', 'Oldies Music',
'Folk Music', 'Documentary',
'Alarm Test', 'Alarm - Alarm !' ]
def __str__(self):
if self.pi is None:
return str(None)
s = 'RDS PI=%-5d' % self.pi
s += ' TP=%d' % self.tp
if self.ta is not None:
s += ' TA=%d' % self.ta
else:
s += ' '
if self.ms is not None:
s += ' MS=%d' % self.ms
else:
s += ' '
s += ' PTY=%-2d %-20s' % (self.pty, '(' + self.ptyTable[self.pty] + ')')
if self.ptyn is not None:
s += ' PTYN=%r' + str(self.ptyn).strip('\x00')
if self.di is not None or self.pserv is not None:
s += '\n '
if self.di is not None:
distr = '('
distr += 'stereo' if self.di & 1 else 'mono'
if self.di & 2:
distr += ',artificial'
if self.di & 4:
distr += ',compressed'
if self.di & 8:
distr += ',dynpty'
distr += ')'
s += ' DI=%-2d %-37s' % (self.di, distr)
else:
s += 45 * ' '
if self.pserv is not None:
s += ' SERV=%r' % str(self.pserv).strip('\x00')
if self.time is not None or self.pin is not None:
s += '\n '
if self.time is not None:
(day, hour, mt, off) = self.time
dt = datetime.date.fromordinal(day + datetime.date(1858, 11, 17).toordinal())
s += ' TIME=%04d-%02d-%02d %02d:%02d UTC ' % (dt.year, dt.month, dt.day, hour, mt)
else:
s += 27 * ' '
if self.pin is not None:
(day, hour, mt) = self.pin
s += ' PIN=d%02d %02d:%02d' % (day, hour, mt)
else:
s += 14 * ' '
if self.af is not None:
s += '\n AF='
for f in self.af:
if f > 1.0e6:
s += '%.1fMHz ' % (f * 1.0e-6)
else:
s += '%.0fkHz ' % (f * 1.0e-3)
if self.rtext is not None:
s += '\n RT=%r' % str(self.rtext).strip('\x00')
return s
def rdsDecode(bits, rdsdata=None):
"""Decode RDS data stream.
bits :: list of RDS data bits
rdsdata :: optional RdsData object to store RDS information
Return (rdsdata, ngroups, errsoft, errhard)
where rdsdata is the updated RdsData object
ngroup is the number of correctly decoded RDS groups
errsoft is the number of correctable bit errors
errhard is the number of uncorrectable bit errors
"""
if rdsdata is None:
rdsdata = RdsData()
ngroup = 0
errsoft = 0
errhard = 0
p = 0
n = len(bits)
while p + 4 * 26 <= n:
(wa, ea) = rdsDecodeBlock(bits[p:p+26], "A")
if wa is None:
errhard += 1
p += 1
continue
(wb, eb) = rdsDecodeBlock(bits[p+26:p+2*26], "B")
if wb is None:
errhard += 1
p += 1
continue
if (wb >> 11) & 1:
(wc, ec) = rdsDecodeBlock(bits[p+2*26:p+3*26], "C'")
else:
(wc, ec) = rdsDecodeBlock(bits[p+2*26:p+3*26], "C")
if wc is None:
errhard += 1
p += 1
continue
(wd, ed) = rdsDecodeBlock(bits[p+3*26:p+4*26], "D")
if wd is None:
errhard += 1
p += 1
continue
errsoft += ea + eb + ec + ed
ngroup += 1
# Found an RDS group; decode it.
typ = (wb >> 12)
typb = (wb >> 11) & 1
# PI, TP, PTY are present in all groups
rdsdata.pi = wa
rdsdata.tp = (wb >> 10) & 1
rdsdata.pty = (wb >> 5) & 0x1f
if typ == 0:
# group type 0: TA, MS, DI, program service name
rdsdata.ta = (wb >> 4) & 1
rdsdata.ms = (wb >> 3) & 1
dseg = wb & 3
if rdsdata.di is None:
rdsdata.di = 0
rdsdata.di &= ~(1 << dseg)
rdsdata.di |= (((wb >> 2) & 1) << dseg)
if rdsdata.pserv is None:
rdsdata.pserv = bytearray(8)
rdsdata.pserv[2*dseg] = wd >> 8
rdsdata.pserv[2*dseg+1] = wd & 0xff
if typ == 0 and not typb:
# group type 0A: alternate frequencies
for f in ((wc >> 8), wc & 0xff):
if f >= 224 and f <= 249:
rdsdata.tmp_aflen = f - 224
rdsdata.tmp_aflfmode = 0
rdsdata.tmp_afs = [ ]
elif f == 250 and rdsdata.tmp_aflen > 0 and len(rdsdata.tmp_afs) < rdsdata.tmp_aflen:
rdsdata.tmp_aflfmode = 1
elif f >= 1 and f <= 204 and rdsdata.tmp_aflen > 0 and len(rdsdata.tmp_afs) < rdsdata.tmp_aflen:
if rdsdata.tmp_aflfmode:
rdsdata.tmp_afs.append(144.0e3 + f * 9.0e3)
else:
rdsdata.tmp_afs.append(87.5e6 + f * 0.1e6)
if len(rdsdata.tmp_afs) == rdsdata.tmp_aflen:
rdsdata.af = rdsdata.tmp_afs
rdsdata.tmp_aflen = 0
rdsdata.tmp_afs = [ ]
rdsdata.tmp_aflfmode = 0
if typ == 1:
# group type 1: program item number
rdsdata.pin = (wd >> 11, (wd >> 6) & 0x1f, wd & 0x3f)
if typ == 2:
# group type 2: radio text
dseg = wb & 0xf
if rdsdata.rtext is None or ((wb >> 4) & 1) != rdsdata.rtextab:
rdsdata.rtext = bytearray(64)
rdsdata.rtextab = (wb >> 4) & 1
if typb:
rdsdata.rtext[2*dseg] = (wd >> 8)
rdsdata.rtext[2*dseg+1] = wd & 0xff
else:
rdsdata.rtext[4*dseg] = (wc >> 8)
rdsdata.rtext[4*dseg+1] = wc & 0xff
rdsdata.rtext[4*dseg+2] = (wd >> 8)
rdsdata.rtext[4*dseg+3] = wd & 0xff
if typ == 4 and not typb:
# group type 4A: clock-time and date
rdsdata.time = (((wb & 3) << 15) | (wc >> 1),
((wc & 1) << 4) | (wd >> 12),
(wd >> 6) & 0x3f, (wd & 0x1f) - (wd & 0x20))
if typ == 10 and not typb:
# group type 10A: program type name
dseg = wb & 1
if rdsdata.ptyn is None or ((wb >> 4) & 1) != rdsdata.ptynab:
rdsdata.ptyn = bytearray(8)
rdsdata.ptynab = (wb >> 4) & 1
rdsdata.ptyn[4*dseg] = (wc >> 8)
rdsdata.ptyn[4*dsseg+1] = wc & 0xff
rdsdata.ptyn[4*dseg+2] = (wd >> 8)
rdsdata.ptyn[4*dsseg+3] = wd & 0xff
# Go to next group.
p += 4 * 26
return (rdsdata, ngroup, errsoft, errhard)
You can’t perform that action at this time.