def __init__(self, sid, sats=None, conf=None):
if conf is None:
conf = cmisc.Attr(
samples_per_chip=kGPS_SAMPLES_PER_CHIP,
samples_freq=kGPS_SAMPLE_FREQ,
match_n_tile=kGPS_FILTER_MATCH_N_TILE,
prn_freq=kGPS_PRN_FREQ,
)
self.conf = conf
self.seq_track = get_l1ca_pulse(sid, self.conf.sample_per_chip)
self.seq_acq = np.tile(self.seq_track, self.conf.match_n_tile)
self.sid = sid
self.data = np.array([])
self.status = Status.INIT
self.sats = sats
self.signal_data = Z.Attributize(power=0)
self.pts_acq = np.arange(len(
self.seq_acq)) * (2j * np.pi / self.conf.samples_freq)
self.pts_track = np.arange(len(
self.seq_track)) * (2j * np.pi / self.conf.samples_freq)
self.stats = []
self.ts = 0
self.new_ts = 0
self.tracking_data = None
self.acq_data = None
def GuessDataSource(data, encoder, fix_align=None, **kwargs):
decs = []
for align in range(encoder.n):
if fix_align is None or fix_align == align:
nd = data[align:]
conf = cmisc.Attr(align=align, data=nd)
conf.dec = ConvViterbi(encoder, **kwargs)
decs.append(conf)
if len(decs) == 1:
return decs[0]
for i in range(0, len(data), encoder.n):
scores = []
for conf in decs:
grp = conf.data[i:i + encoder.n]
if len(grp) != encoder.n: continue
conf.dec.setup_next(grp)
if conf.dec.fail: continue
scores.append((conf.dec.get_max_likelyhood(), conf))
scores.sort(reverse=True, key=lambda x: x[0])
glog.info('Got scores %s' % scores)
if len(scores) == 0: break
if len(scores) == 1 or scores[0][0] > scores[1][0] + 30:
return scores[0][1]
return None
def real_decode(ctx):
d = Z.pickle.load(open(ctx.infile, 'rb'))
samples_per_prn = d.samples_per_chip * d.chips_per_prn
pl = []
conf = cmisc.Attributize(
sample_rate=d.sample_rate,
sps=d.samples_per_chip * d.chips_per_prn,
symbol_rate=d.prn_freq,
n_acq_symbol=20,
max_doppler_shift=0,
doppler_space_size=1,
SNR_THRESH=10,
jitter=0,
)
start_pos = samples_per_prn
cx = d.signal
cur_ctx = cmisc.Attr(orig_sig=cx, cleaned_sig=cx[start_pos:])
prevs = []
for i in range(len(d.orig_data)):
if i == -1:
print('goot')
g = K.GraphHelper(run_in_jupyter=0)
x = g.create_plot(plots=[
np.abs(cx),
np.abs(d.signal[start_pos:start_pos + len(cx)])
])
g.run()
return
conf.pulse_shape = get_l1ca_pulse(d.orig_data[i].sat,
d.samples_per_chip)
p = OpaXpsk(conf)
cur_ctx.i = i
dd = process_bits_xpsk(p, cur_ctx, 20 - 2 * i, d.orig_data[i].doppler,
prevs, start_pos, d.orig_data[i])
cur_ctx.cleaned_sig = dd.nsig
prevs.append(dd)
start_pos = dd.nstart_pos
bits = dd.bits >= 0.5
print(dd.bits, len(bits))
print(Z.min_substr_diff(d.orig_data[i].bin_data, bits))
print(Z.min_substr_diff(d.orig_data[i].bin_data, 1 ^ bits))
print(d.orig_data[i].bin_data)
print()
#d2 = process_bits_xpsk(p, d1.nsig[samples_per_prn:], 5)
print(Z.DataOp.Power_Db(cx))
return
for i in range(1, 6):
conf.pulse_shape = get_l1ca_pulse(i, d.samples_per_chip)
p = OpaXpsk(conf)
r = p.analyse_chip(d.orig_data[i].doppler, cx)
print(r)
break
def snapshot(self, want, failsafe=0):
res = {}
for x in want:
try:
res[x] = self[x]
except:
if not failsafe:
raise
return cmisc.Attr(res)
def get_ins_info(self, cpc, regs=[], mem=[], funcs={}, prev_regs=[]):
ins_data = self.get_ins_data(cpc)
ins_str = self.arch.mc.ins_str(ins_data, addr=cpc)
ins_str2 = self.get_ins_str_gdb(pc=cpc)
res = cmisc.Attr(pc=cpc, ins_str2=ins_str2, ins_data=ins_data, failed=0, data={})
try:
ins = self.arch.mc.get_one_ins(ins_data, addr=cpc)
regcheck= self.arch.mc.get_reg_ops(ins)
except:
regcheck=['v0', 'v1', 'v2']
res.failed = 1
nregs = []
for reg in regcheck:
if reg in ('fp',): continue
if reg[0] == 'v':
nregs.append(reg + '.q.s[0]')
nregs.append(reg + '.q.u[0]')
else:
nregs.append(reg)
cregs = list(nregs) + regs
cregs.extend(prev_regs)
prev_regs = nregs
cmem = list(mem)
if cpc in funcs:
cf = funcs[cpc]
cmem.extend(cf.get('mem', []))
cregs.extend(cf.get('regs', []))
res.name = cf.name
res.regs= self.snapshot_regs(cregs, main_obj=res.data, failsafe=1)
res.mem= self.snapshot_mem(cmem, res.data)
return cmisc.Attr(res=res, prev_regs=prev_regs)
def process_bits_xpsk(p,
cur_ctx,
nbits,
freq,
prevs,
start_pos,
orig_data=None):
print('\nNew processing on sig db: ',
Z.DataOp.Power_Db(cur_ctx.cleaned_sig))
r = p.analyse_chip(freq, cur_ctx.cleaned_sig[:p.acq_proc_size], start_pos)
p.init_tracking_data(r)
print(r)
print(start_pos)
sym_phases = list(r.sym_phases)
start_phase = r.phase
nstart_pos = start_pos + start_phase
cur_phase = start_phase + p.conf.sps * len(sym_phases)
for i in range(nbits):
cx = cur_ctx.cleaned_sig[cur_phase:cur_phase + p.conf.sps]
nr = p.analyse_chip(freq, cx, start_pos + cur_phase, acq=0)
sym_phases.append(nr.sym_phase)
cur_phase += p.conf.sps
bits = Z.DataOp.GetBPSKBits(sym_phases)
syms = 2 * bits - 1
#syms = np.exp(1j * np.array(sym_phases))
print('NBITS >> ', len(syms))
sb = SignalBuilder(nstart_pos,
n=p.conf.sps * len(syms),
dtype=np.complex128)
sb.add_multiple(nstart_pos, syms, p.conf.pulse_shape, p.conf.sps)
sb.doppler_shift(freq, p.conf.sample_rate)
tb = []
#sz=3000
#if cur_ctx.i!=1: sz=-1
for prev in prevs:
#tb.append(sb.extract_peer(prev.orig_data.sb)[:sz])
tb.append(sb.extract_peer(prev.sb))
rebuilt = sb.get()
tb.append(rebuilt)
orig = sb.extract(0, cur_ctx.orig_sig)
vec, sig_space = solve_least_squares(tb, orig)
print('LEAST SQURE SOL ', vec)
print('GOOOT', Z.DataOp.Power_Db(orig - sig_space))
nsig = orig - sig_space
print(Z.min_substr_diff(orig_data.bin_data, bits))
print(Z.min_substr_diff(orig_data.bin_data, 1 ^ bits))
#rebuilt = sb.extract_peer(orig_data.sb)
if cur_ctx.i == -1:
sbx = SignalBuilder(0, n=p.conf.sps, dtype=np.complex128)
sbx.add(0, p.conf.pulse_shape)
sbx.doppler_shift(freq, p.conf.sample_rate)
g = K.GraphHelper(run_in_jupyter=0)
x = g.create_plot(plots=[
np.angle(rebuilt) + np.angle(sb.extract_peer(orig_data.sb))
])
#x = g.create_plot(plots=[np.angle(sb.extract_peer(orig_data.sb))])
#x = g.create_plot(plots=[np.log10(np.abs(Z.signal.correlate(cur_ctx.cleaned_sig, sbx.get())))])
x = g.create_plot(plots=[
np.log10(np.abs(Z.signal.correlate(cur_ctx.orig_sig, sbx.get())))
])
x = g.create_plot(plots=[
np.log10(np.abs(Z.signal.correlate(orig_data.sb.get(), sbx.get())))
])
x = g.create_plot(plots=[
np.log10(np.abs(Z.signal.correlate(cur_ctx.cleaned_sig,
sbx.get())))
])
x = g.create_plot(
plots=[np.log10(np.abs(Z.signal.correlate(sb.get(), sbx.get())))])
g.run()
return
print(Z.DataOp.GetBPSKBits(sym_phases))
print(np.abs(np.diff(np.unwrap(sym_phases))))
return cmisc.Attr(nsig=nsig,
start_phase=start_phase,
rebuilt=rebuilt,
bits=bits,
sb=sb,
orig_data=orig_data,
nstart_pos=nstart_pos)
def generate_test_bpsk(ctx):
samples_per_chip = 5
chips_per_prn = 1023
ndata = 100
sb = SignalBuilder(0,
samples_per_chip * (ndata + 1) * chips_per_prn,
dtype=np.complex128)
sats = list(range(4))
nsats = len(sats)
powers_db = [-0, -20, -30, -30]
#powers_db = [-0, 0, 0, 0]
noise_db = -60
prns = [get_l1ca_pulse(sid, samples_per_chip) for sid in sats]
offsets = [0.0, 0.1, 0.5, 0.8]
dopplers = [10000, 1000, -1000, 0]
phase_start = [0, 6.3, 1.7, 1.3]
nsats = 4
data = cmisc.Attr()
data.orig_data = []
data.samples_per_chip = samples_per_chip
data.chips_per_prn = chips_per_prn
data.prn_freq = kGPS_PRN_FREQ
data.sample_rate = samples_per_chip * chips_per_prn * data.prn_freq
prn_ts = np.arange(samples_per_chip * chips_per_prn) / data.sample_rate
for i in range(nsats):
sig_data = cmisc.Attr()
prn = prns[i]
power_db = powers_db[i]
offset = int(offsets[i] * samples_per_chip * chips_per_prn)
prn_pw = Z.DataOp.Power(prn)
pulse = prn * (10**(power_db / 20) / prn_pw)
bin_data = np.random.randint(2, size=ndata)
cur_data = 2 * bin_data - 1
phase = phase_start[i]
doppler = dopplers[i]
cur_sb = sb.make_new()
cur_sb.add_multiple(offset, cur_data, pulse, len(pulse))
cur_sb.doppler_shift(doppler, data.sample_rate)
sb.add_peer(cur_sb)
sig_data.prn = prn
sig_data.power_db = power_db
sig_data.offset = offset
sig_data.sat = sats[i]
sig_data.phase = phase
sig_data.doppler = doppler
sig_data.bin_data = bin_data
sig_data.signal = cur_sb.get()
sig_data.sb = cur_sb
data.orig_data.append(sig_data)
print(power_db, Z.DataOp.Power_Db(sig_data.signal), offset)
if 0:
g = K.GraphHelper(run_in_jupyter=0)
x = g.create_plot(plots=[np.angle(cur_sb.get())])
g.run()
assert 0
res = sb.get()
if noise_db is not None:
data.noiseless = np.array(res)
noise = np.random.normal(scale=10**(noise_db / 20), size=len(res))
print(noise_db, Z.DataOp.Power_Db(noise))
data.noise = noise
res += noise
print(len(res))
data.signal = res
Z.pickle.dump(data, open(ctx.outfile, 'wb'))
def __init__(self):
self.par = defaultdict(lambda: -1)
self.data = cmisc.Attr(
handler=lambda u: (cmisc.Attr(handler=lambda x: (x, 1)), 1))
def get_snapshot(self, nstack=0):
regs = self.regs.snapshot_all()
mem = []
for i in range(nstack):
mem.append(self.stack.get(i))
return cmisc.Attr(regs=regs, mem=mem)
def snapshot_mem(mem, segs):
res = []
for seg in segs:
content = mem.read(seg.low, seg.n)
res.append((seg, content))
return cmisc.Attr(data=res, arch=mem.arch.typ)
