From 059eb97446a52b346a550d12f47478fc978b6001 Mon Sep 17 00:00:00 2001 From: andreas128 Date: Sun, 8 Jan 2017 14:59:52 +0000 Subject: Add two_tone_lib and tested two_tone_tuner --- .gitignore | 12 +++ live_analyse.grc | 2 +- live_analyse_py.grc | 252 +-------------------------------------------------- src/tcp_async.py | 83 +++++++++++++++++ src/tcp_sync.py | 108 ++++++++++++++++++++++ src/two_tone_lib.py | 75 +++++++++++++++ tcp_async.py | 83 ----------------- tcp_sync.py | 108 ---------------------- two_tone_tuner.ipynb | 197 ++++++++++++++++++++++++++++++++++++++++ 9 files changed, 480 insertions(+), 440 deletions(-) create mode 100644 src/tcp_async.py create mode 100644 src/tcp_sync.py create mode 100644 src/two_tone_lib.py delete mode 100644 tcp_async.py delete mode 100644 tcp_sync.py create mode 100644 two_tone_tuner.ipynb diff --git a/.gitignore b/.gitignore index cbdc681..0eb1cf3 100644 --- a/.gitignore +++ b/.gitignore @@ -28,6 +28,18 @@ top_block.py Untitled.ipynb Untitled.py Untitled.txt +Untitled1.ipynb +Untitled1.py +Untitled1.txt +input.dat +input.dat.png +input.dat_fft.png +live_analyse_py.py +myplot.pickle +run.py +run.txt +two_tone_tuner.py + diff --git a/live_analyse.grc b/live_analyse.grc index 737798e..ff33842 100644 --- a/live_analyse.grc +++ b/live_analyse.grc @@ -461,7 +461,7 @@ file - /home/andreas/dab/dab_normalized_c64.dat + /home/andreas/dab/ODR-StaticPrecorrection/input.dat _coordinate diff --git a/live_analyse_py.grc b/live_analyse_py.grc index b380b70..f24bcab 100644 --- a/live_analyse_py.grc +++ b/live_analyse_py.grc @@ -243,53 +243,6 @@ 50 - - analog_const_source_x - - alias - - - - comment - - - - const - 0 - - - affinity - - - - _enabled - True - - - _coordinate - (896, 76) - - - _rotation - 0 - - - id - analog_const_source_x_0 - - - maxoutbuf - 0 - - - minoutbuf - 0 - - - type - complex - - blks2_tcp_sink @@ -365,7 +318,7 @@ _coordinate - (1240, 343) + (800, 343) _rotation @@ -392,57 +345,6 @@ 8192 - - blocks_add_xx - - alias - - - - comment - - - - affinity - - - - _enabled - True - - - _coordinate - (1112, 121) - - - _rotation - 0 - - - id - blocks_add_xx_1 - - - type - complex - - - maxoutbuf - 0 - - - minoutbuf - 0 - - - num_inputs - 2 - - - vlen - 1 - - blocks_file_source @@ -545,128 +447,6 @@ 1 - - blocks_multiply_const_vxx - - alias - - - - comment - - - - const - 1 - - - affinity - - - - _enabled - True - - - _coordinate - (784, 148) - - - _rotation - 0 - - - id - blocks_multiply_const_vxx_1 - - - type - complex - - - maxoutbuf - 0 - - - minoutbuf - 0 - - - vlen - 1 - - - - dpd_memless_poly - - alias - - - - comment - - - - affinity - - - - _enabled - True - - - _coordinate - (576, 99) - - - _rotation - 0 - - - id - dpd_memless_poly_0 - - - maxoutbuf - 0 - - - minoutbuf - 0 - - - a1 - 1 - - - a2 - 0 - - - a3 - 0 - - - a4 - 0 - - - a5 - 0 - - - a6 - 0 - - - a7 - 0 - - - a8 - 0 - - logpwrfft_x @@ -703,7 +483,7 @@ _coordinate - (848, 329) + (568, 329) _rotation @@ -1449,7 +1229,7 @@ _coordinate - (1232, 95) + (704, 111) _rotation @@ -2675,21 +2455,9 @@ - - analog_const_source_x_0 - blocks_add_xx_1 - 0 - 0 - - - blocks_add_xx_1 - uhd_usrp_sink_0 - 0 - 0 - blocks_file_source_0 - dpd_memless_poly_0 + uhd_usrp_sink_0 0 0 @@ -2699,18 +2467,6 @@ 0 0 - - blocks_multiply_const_vxx_1 - blocks_add_xx_1 - 0 - 1 - - - dpd_memless_poly_0 - blocks_multiply_const_vxx_1 - 0 - 0 - logpwrfft_x_0 blks2_tcp_sink_1_0 diff --git a/src/tcp_async.py b/src/tcp_async.py new file mode 100644 index 0000000..05cadd7 --- /dev/null +++ b/src/tcp_async.py @@ -0,0 +1,83 @@ +"""Tcp client for asynchronous uhd message tcp port""" + +import threading +import Queue +import time +import socket + +class _TcpAsyncClient(threading.Thread): + """Thead for message polling""" + queue = Queue.Queue() + q_quit = Queue.Queue() + + ip_address = None + port = None + BUFFER_SIZE = 1 + + def __init__(self, ip_address, port): + super(_TcpAsyncClient, self).__init__() + self.ip_address = ip_address + self.port = port + + def __exit__(self): + self.stop() + + def run(self): + """connect and poll messages to queue""" + + #Establish connection + sock = None + print("Connecting to asynchronous uhd message tcp port " + str(self.port)) + while self.q_quit.empty(): + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.connect((self.ip_address, self.port)) + break + except socket.error: + print("connecting to asynchronous uhd message tcp port " + str(self.port)) + #traceback.print_exc() + sock.close() + time.sleep(0.5) + print("Connected to asynchronous uhd message tcp port " + str(self.port)) + + #Read messages + sock.settimeout(1) + while self.q_quit.empty(): + try: + data = sock.recv(self.BUFFER_SIZE) + self.queue.put(data) + except socket.timeout: + pass + + sock.close() + + def stop(self): + """stop thread""" + print("stop tcp_async uhd message tcp thread") + self.q_quit.put("end") + + +class UhdAsyncMsg(object): + """Creates a thread to connect to the asynchronous uhd messages tcp port""" + + def __init__(self, ip_address = "127.0.0.1", port = 47010): + self.tcpa = _TcpAsyncClient(ip_address, port) + self.tcpa.start() + + def __exit__(self): + self.tcpa.stop() + + def stop(self): + """stop tcp thread""" + self.tcpa.stop() + + def get_res(self): + """get received messages as string of integer""" + out = "" + while not self.tcpa.queue.empty(): + out += str(ord(self.tcpa.queue.get())) + return out + + def has_msg(self): + """Checks if one or more messages were received and empties the message queue""" + return self.get_res() != "" diff --git a/src/tcp_sync.py b/src/tcp_sync.py new file mode 100644 index 0000000..6a2e619 --- /dev/null +++ b/src/tcp_sync.py @@ -0,0 +1,108 @@ +"""Tcp client for synchronous uhd message tcp port""" + +import threading +import Queue +import time +import socket +import struct + +class _TcpSyncClient(threading.Thread): + """Thead for message polling""" + queue = Queue.Queue() + q_quit = Queue.Queue() + + ip_address = None + port = None + + def __init__(self, ip_address, port, packet_size, packet_type): + super(_TcpSyncClient, self).__init__() + self.ip_address = ip_address + self.port = port + self.packet_size = packet_size + self.packet_type = packet_type + + def __exit__(self): + self.stop() + + def run(self): + """connect and poll messages to queue""" + + #Establish connection + sock = None + print("Connecting to synchronous uhd message tcp port " + str(self.port)) + while self.q_quit.empty(): + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.connect((self.ip_address, self.port)) + break + except socket.error: + print("connecting to synchronous uhd message tcp port " + str(self.port)) + #traceback.print_exc() + sock.close() + time.sleep(0.5) + print("Connected to synchronous uhd message tcp port " + str(self.port)) + + #Read messages + sock.settimeout(None) + while self.q_quit.empty(): + try: + s = "" + + #concatenate to one package + while self.q_quit.empty(): + s += sock.recv(self.packet_size) + if (len(s)) == self.packet_size: + break + if (len(s)) > self.packet_size: + print("received wrong size of length " + str(len(s))) + time.sleep(0.01) + return -1 + + res_tuple = struct.unpack( + self.packet_type, + s) + self.queue.put(res_tuple) + except socket.timeout: + self.stop() + traceback.print_exc() + pass + + sock.close() + + def stop(self): + """stop thread""" + print("stop tcp_sync uhd message tcp thread") + self.q_quit.put("end") + + +class UhdSyncMsg(object): + """Creates a thread to connect to the synchronous uhd messages tcp port""" + + def __init__(self, ip_address = "127.0.0.1", port = 47009, packet_size = 3, packet_type = "fff"): + self.tcpa = _TcpSyncClient(ip_address, port, packet_size, packet_type) + self.tcpa.start() + + def __exit__(self): + self.tcpa.stop() + + def stop(self): + """stop tcp thread""" + self.tcpa.stop() + + def get_msgs(self, num): + """get received messages as string of integer""" + out = [] + while len(out) < num: + out.append(self.tcpa.queue.get()) + return out + + def get_res(self): + """get received messages as string of integer""" + out = [] + while not self.tcpa.queue.empty(): + out.append(self.tcpa.queue.get()) + return out + + def has_msg(self): + """Checks if one or more messages were received and empties the message queue""" + return self.get_res() != "" diff --git a/src/two_tone_lib.py b/src/two_tone_lib.py new file mode 100644 index 0000000..df7d53f --- /dev/null +++ b/src/two_tone_lib.py @@ -0,0 +1,75 @@ +import numpy as np +import matplotlib.pyplot as plt + +def gen_two_tone(path = "./input.dat", predist = None, par = None, debug = False): + period1 = 3.875 + period2 = 4 + t_both = 124 + assert(t_both / period1 % 1 == 0) + assert(t_both / period2 % 1 == 0) + + t = np.arange(0,t_both) + sin1 = np.sin(t * 2 * np.pi * 1./period1) + sin2 = np.sin(t * 2 * np.pi * 1./period2) + sig = sin1 + sin2 + + if predist is None: + res = sig + else: + res = predist(sig, par) + + res = res / np.max(res) + + res = res.astype(np.complex64) + res.tofile(path) + + a_load = np.fromfile(path, dtype=np.complex64) + assert(np.isclose(a_load, res).all()), "Inconsistent stored file" + + if debug == True: + plt.plot(np.abs(np.concatenate((a_load, a_load)))) + plt.savefig(path + ".png") + plt.clf() + + plt.plot(np.abs(np.fft.fftshift(np.fft.fft(np.concatenate((a_load, a_load))))), 'ro') + plt.savefig(path + "_fft.png") + plt.clf() + + return path + +def predist_poly(sig, coefs = []): + res = sig + for idx, coef in enumerate(coefs): + res += sig * np.abs(sig)**(idx+1) * coef #+1 because first correction term is squared + return res + +def analyse_power_spec(spec, debug = False, debug_path="", suffix=""): + peak_1 = None + peak_2 = None + spec_start = 4096 + spec_end = 8192 + first_peak = spec_start + 2048 + second_peak = spec_start + 2114 + delta_freq = 66 + peak_other = [] + if debug: plt.plot(spec[spec_start:spec_end]) + for x in [c * delta_freq + delta_freq//2 for c in range(spec_start//delta_freq)]: + start = spec_start + x + end = spec_start + x + delta_freq + peak = spec[start:end].max() + if debug: plt.plot((start-spec_start,end-spec_start), (peak, peak)) + if start < first_peak and end > first_peak: + peak_1 = peak + if debug: plt.plot((start-spec_start,end-spec_start), (peak+1, peak+1)) + elif start < second_peak and end > second_peak: + peak_2 = peak + if debug: plt.plot((start-spec_start,end-spec_start), (peak+1, peak+1)) + else: + peak_other.append(peak) + mean_signal = (peak_1 + peak_2) / 2 + mean_others = np.mean(peak_other) + score = mean_signal - mean_others + if debug: + plt.savefig(debug_path + "/" + str(score) + suffix + ".png") + plt.clf() + return score diff --git a/tcp_async.py b/tcp_async.py deleted file mode 100644 index 05cadd7..0000000 --- a/tcp_async.py +++ /dev/null @@ -1,83 +0,0 @@ -"""Tcp client for asynchronous uhd message tcp port""" - -import threading -import Queue -import time -import socket - -class _TcpAsyncClient(threading.Thread): - """Thead for message polling""" - queue = Queue.Queue() - q_quit = Queue.Queue() - - ip_address = None - port = None - BUFFER_SIZE = 1 - - def __init__(self, ip_address, port): - super(_TcpAsyncClient, self).__init__() - self.ip_address = ip_address - self.port = port - - def __exit__(self): - self.stop() - - def run(self): - """connect and poll messages to queue""" - - #Establish connection - sock = None - print("Connecting to asynchronous uhd message tcp port " + str(self.port)) - while self.q_quit.empty(): - try: - sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - sock.connect((self.ip_address, self.port)) - break - except socket.error: - print("connecting to asynchronous uhd message tcp port " + str(self.port)) - #traceback.print_exc() - sock.close() - time.sleep(0.5) - print("Connected to asynchronous uhd message tcp port " + str(self.port)) - - #Read messages - sock.settimeout(1) - while self.q_quit.empty(): - try: - data = sock.recv(self.BUFFER_SIZE) - self.queue.put(data) - except socket.timeout: - pass - - sock.close() - - def stop(self): - """stop thread""" - print("stop tcp_async uhd message tcp thread") - self.q_quit.put("end") - - -class UhdAsyncMsg(object): - """Creates a thread to connect to the asynchronous uhd messages tcp port""" - - def __init__(self, ip_address = "127.0.0.1", port = 47010): - self.tcpa = _TcpAsyncClient(ip_address, port) - self.tcpa.start() - - def __exit__(self): - self.tcpa.stop() - - def stop(self): - """stop tcp thread""" - self.tcpa.stop() - - def get_res(self): - """get received messages as string of integer""" - out = "" - while not self.tcpa.queue.empty(): - out += str(ord(self.tcpa.queue.get())) - return out - - def has_msg(self): - """Checks if one or more messages were received and empties the message queue""" - return self.get_res() != "" diff --git a/tcp_sync.py b/tcp_sync.py deleted file mode 100644 index 6a2e619..0000000 --- a/tcp_sync.py +++ /dev/null @@ -1,108 +0,0 @@ -"""Tcp client for synchronous uhd message tcp port""" - -import threading -import Queue -import time -import socket -import struct - -class _TcpSyncClient(threading.Thread): - """Thead for message polling""" - queue = Queue.Queue() - q_quit = Queue.Queue() - - ip_address = None - port = None - - def __init__(self, ip_address, port, packet_size, packet_type): - super(_TcpSyncClient, self).__init__() - self.ip_address = ip_address - self.port = port - self.packet_size = packet_size - self.packet_type = packet_type - - def __exit__(self): - self.stop() - - def run(self): - """connect and poll messages to queue""" - - #Establish connection - sock = None - print("Connecting to synchronous uhd message tcp port " + str(self.port)) - while self.q_quit.empty(): - try: - sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - sock.connect((self.ip_address, self.port)) - break - except socket.error: - print("connecting to synchronous uhd message tcp port " + str(self.port)) - #traceback.print_exc() - sock.close() - time.sleep(0.5) - print("Connected to synchronous uhd message tcp port " + str(self.port)) - - #Read messages - sock.settimeout(None) - while self.q_quit.empty(): - try: - s = "" - - #concatenate to one package - while self.q_quit.empty(): - s += sock.recv(self.packet_size) - if (len(s)) == self.packet_size: - break - if (len(s)) > self.packet_size: - print("received wrong size of length " + str(len(s))) - time.sleep(0.01) - return -1 - - res_tuple = struct.unpack( - self.packet_type, - s) - self.queue.put(res_tuple) - except socket.timeout: - self.stop() - traceback.print_exc() - pass - - sock.close() - - def stop(self): - """stop thread""" - print("stop tcp_sync uhd message tcp thread") - self.q_quit.put("end") - - -class UhdSyncMsg(object): - """Creates a thread to connect to the synchronous uhd messages tcp port""" - - def __init__(self, ip_address = "127.0.0.1", port = 47009, packet_size = 3, packet_type = "fff"): - self.tcpa = _TcpSyncClient(ip_address, port, packet_size, packet_type) - self.tcpa.start() - - def __exit__(self): - self.tcpa.stop() - - def stop(self): - """stop tcp thread""" - self.tcpa.stop() - - def get_msgs(self, num): - """get received messages as string of integer""" - out = [] - while len(out) < num: - out.append(self.tcpa.queue.get()) - return out - - def get_res(self): - """get received messages as string of integer""" - out = [] - while not self.tcpa.queue.empty(): - out.append(self.tcpa.queue.get()) - return out - - def has_msg(self): - """Checks if one or more messages were received and empties the message queue""" - return self.get_res() != "" diff --git a/two_tone_tuner.ipynb b/two_tone_tuner.ipynb new file mode 100644 index 0000000..0272401 --- /dev/null +++ b/two_tone_tuner.ipynb @@ -0,0 +1,197 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import time\n", + "import src.gen_source as gen_source\n", + "import src.two_tone_lib as tt\n", + "\n", + "import src.tcp_async as tcp_async\n", + "import src.tcp_sync as tcp_sync\n", + "\n", + "from live_analyse_py import live_analyse_py" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " __IPYTHON__\n", + " reload(tcp_async)\n", + " reload(tcp_sync)\n", + " reload(gen_source)\n", + " reload(tt)\n", + "except:\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sync = tcp_sync.UhdSyncMsg(packet_size=4*8192,\n", + " packet_type=\"\".join([\"f\"]*8192))\n", + "async = tcp_async.UhdAsyncMsg()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "top = live_analyse_py()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "top.start()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sync.has_msg()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def measure(param):\n", + " x2 = param[0]\n", + " x3 = param[1]\n", + " x4 = param[2]\n", + " repeat = True\n", + " while repeat:\n", + " tt.gen_two_tone(debug = True, predist=tt.predist_poly, par=(x2, x3, x4))\n", + " sync.has_msg()\n", + " np.array(sync.get_msgs(2))\n", + " msgs = np.array(sync.get_msgs(5))\n", + " msgs = [np.fft.fftshift(msg) for msg in msgs]\n", + " \n", + " if async.has_msg():\n", + " continue\n", + " \n", + " a = np.array(msgs)\n", + " mean_msg = a.mean(axis = 0)\n", + " suffix = \"x_2_%.3f_x_3_%.3f_x_4_%.3f\" % (x2, x3, x4)\n", + " sig_to_noise = tt.analyse_power_spec(mean_msg, debug=True, debug_path=\"/tmp/out\", suffix=suffix)\n", + " print(sig_to_noise, x2, x3, x4)\n", + " repeat = False" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "top.set_txgain(85)\n", + "\n", + "params = []\n", + "for x2 in np.linspace(-0.1, 0.1, num = 11):\n", + " for x3 in np.linspace(-0.1, 0.1, num = 11):\n", + " for x4 in np.linspace(-0.1, 0.1, num = 11):\n", + " params.append((x2, x3, x4))\n", + " \n", + "t_start = time.time()\n", + "for idx, param in enumerate(params):\n", + " measure(param)\n", + " time_per_element = (time.time() - t_start) / (idx + 1)\n", + " print (\"Time per Element \" + str(time_per_element) +\n", + " \", total: \" + str(time_per_element * len(params)),\n", + " \", left: \" + str(time_per_element * (len(params) - 1 - idx))\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sync.stop()\n", + "async.stop()\n", + "top.stop()\n", + "top.wait()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} -- cgit v1.2.3