test_radio_multipacket.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: Qt4Agg\n",
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab\n",
    "# Import functions and libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pyaudio\n",
    "import Queue\n",
    "import threading,time\n",
    "import sys\n",
    "\n",
    "from numpy import pi\n",
    "from numpy import sin\n",
    "from numpy import zeros\n",
    "from numpy import r_\n",
    "from numpy import ones\n",
    "from scipy import signal\n",
    "from scipy import integrate\n",
    "from __future__ import division\n",
    "\n",
    "import threading,time\n",
    "import multiprocessing\n",
    "\n",
    "from rtlsdr import RtlSdr, limit_time\n",
    "from numpy import mean\n",
    "from numpy import power\n",
    "from numpy.fft import fft\n",
    "from numpy.fft import fftshift\n",
    "from numpy.fft import ifft\n",
    "from numpy.fft import ifftshift\n",
    "import bitarray\n",
    "from  scipy.io.wavfile import read as wavread\n",
    "import serial\n",
    "\n",
    "\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from radio import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2205.0\n"
     ]
    }
   ],
   "source": [
    "fs = 44100  # sampling rate\n",
    "Ns = 20 # samples per bit\n",
    "baud = float(fs)/Ns  # symbol rate\n",
    "print(baud)\n",
    "\n",
    "f_low = 1102.5\n",
    "f_high = 2205\n",
    "\n",
    "Nbits_packet = 4800\n",
    "wait_len = 160\n",
    "\n",
    "between_len = wait_len * 2\n",
    "\n",
    "msg_len = Ns * Nbits_packet\n",
    "\n",
    "pulse = genChirpPulse(1600, 500.0, 3500.0, 44100.0)\n",
    "pulse = pulse.real / 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def build_packet(bits):\n",
    "    msg = afsk(1.0 * bits, f_low, f_high, baud, fs)\n",
    "    return np.hstack([pulse, np.zeros(wait_len), msg])\n",
    "\n",
    "def findPackets(sig, fs_down=fs):\n",
    "    pulse_re = signal.resample(pulse, len(pulse) * float(fs_down) / float(fs))\n",
    "    corr = abs(crossCorr(sig, pulse_re))\n",
    "    thres = np.median(corr) * 10\n",
    "    \n",
    "    packets = []\n",
    "    \n",
    "    wait_len_adj = wait_len * float(fs_down) / float(fs)\n",
    "    msg_len_adj = msg_len * float(fs_down) / float(fs)\n",
    "    \n",
    "    packet_len_adj = len(pulse_re) + wait_len_adj + msg_len_adj \n",
    "    \n",
    "    ps = []\n",
    "    \n",
    "    for i in range(0, len(corr), int(packet_len_adj)):\n",
    "        c = corr[i:i+packet_len_adj]\n",
    "        if sum(c > thres) > 0:\n",
    "            ps.append(np.argmax(c) + i)\n",
    "    \n",
    "    #ps = np.where(corr > thres)[0]\n",
    "    \n",
    "    last_flag = -1\n",
    "    \n",
    "    for p in ps:\n",
    "        start, end = int(p + wait_len_adj), int(p + msg_len_adj + wait_len_adj)\n",
    "        \n",
    "        if end >= len(sig):\n",
    "            last_flag = start - len(pulse_re) - wait_len_adj - 100\n",
    "            break\n",
    "        else:\n",
    "            packets.append(sig[start:end])\n",
    "    \n",
    "    return packets, last_flag\n",
    "\n",
    "def decodePacket(pp, fs_down=fs):\n",
    "    demod = nc_afsk_demod(pp, f_low, f_high, TBW=1.5, fs=fs_down)\n",
    "    #demod = demod - np.mean(demod)\n",
    "    decoded = decode_bits2(np.sign(demod), fs=fs_down, baud=baud)\n",
    "    return decoded\n",
    "\n",
    "def get_packets(sig, fs_down=fs):\n",
    "    sigs = findPackets(sig, fs_down)\n",
    "    decodes = [decodePacket(s, fs_down) for s in sigs]\n",
    "    return decodes\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Nbits = Nbits_packet  # number of bits\n",
    "bits = randn(Nbits) > 0\n",
    "N_packets = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 HDA NVidia: CS4206 Analog (hw:0,0)\n",
      "1 HDA NVidia: CS4206 Digital (hw:0,1)\n",
      "2 HDA NVidia: HDMI 0 (hw:0,3)\n",
      "3 HDA NVidia: HDMI 0 (hw:0,7)\n",
      "4 HDA NVidia: HDMI 0 (hw:0,8)\n",
      "5 USB PnP Sound Device: Audio (hw:1,0)\n",
      "6 sysdefault\n",
      "7 front\n",
      "8 surround21\n",
      "9 surround40\n",
      "10 surround51\n",
      "11 surround71\n",
      "12 iec958\n",
      "13 spdif\n",
      "14 hdmi\n",
      "15 pulse\n",
      "16 dmixout\n",
      "17 dmix\n",
      "18 default\n"
     ]
    }
   ],
   "source": [
    "def printDevNumbers(p):\n",
    "    N = p.get_device_count()\n",
    "    for n in range(0,N):\n",
    "        name = p.get_device_info_by_index(n).get('name')\n",
    "        print n, name\n",
    "        \n",
    "p = pyaudio.PyAudio()\n",
    "printDevNumbers(p)\n",
    "p.terminate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# CHANGE!!!!\n",
    "dusb_in = 5\n",
    "dusb_out = 5\n",
    "din = 0\n",
    "dout = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if sys.platform == 'darwin':  # Mac\n",
    "    s = serial.Serial(port='/dev/tty.SLAB_USBtoUART')\n",
    "else:                         #windows\n",
    "    s = serial.Serial(port='/dev/ttyUSB0') ##### CHANGE !!!!!!\n",
    "s.setDTR(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    sdr = RtlSdr()\n",
    "except IOError:\n",
    "    print('defined already')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#sdr.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "zero_sample = np.zeros(int(44100 * 0.3))\n",
    "\n",
    "packet = build_packet(bits)\n",
    "\n",
    "record_len = int(((len(packet) + between_len) / float(fs))*N_packets) + 2\n",
    "if record_len % 2 != 0:\n",
    "    record_len += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "record_len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "freq_offset = 83.2e3\n",
    "\n",
    "sample_rate = 240e3\n",
    "center_freq = 443.582e6 - freq_offset\n",
    "#center_freq = 145.442e6 #- freq_offset\n",
    "\n",
    "sdr.sample_rate = sample_rate  \n",
    "sdr.center_freq = center_freq   \n",
    "sdr.gain = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# def callback(test, obj):\n",
    "#     print(test)\n",
    "#     #obj.cancel_read_async()\n",
    "\n",
    "# N_samples = sample_rate*0.5 # approximately seconds\n",
    "# sdr.read_samples_async(limit_time(1)(callback), N_samples)   # get samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#sdr.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# creates a queue\n",
    "Qout = Queue.Queue()\n",
    "\n",
    "# initialize a serial port \n",
    "s.setDTR(0)\n",
    "# create a pyaudio object\n",
    "p = pyaudio.PyAudio()\n",
    "\n",
    "t_play = threading.Thread(target = play_audio,   args = (Qout,   p, 44100, dusb_out, s ,0.2 ))\n",
    "\n",
    "#Qout.put(sig2)\n",
    "Qout.put(\"KEYON\")\n",
    "Qout.put(zero_sample)\n",
    "\n",
    "for i in range(N_packets):\n",
    "    Qout.put(packet)\n",
    "    Qout.put(np.zeros(between_len))\n",
    "\n",
    "Qout.put(np.zeros(1024))\n",
    "Qout.put(\"KEYOFF\")\n",
    "Qout.put(\"EOT\")\n",
    "\n",
    "# play audio from Queue \n",
    "t_play.start()\n",
    "\n",
    "sdr_samples = np.array([])\n",
    "left = record_len\n",
    "\n",
    "samples = []\n",
    "\n",
    "# N_samples = sample_rate*80 # approximately seconds\n",
    "# ss = sdr.read_samples(N_samples)   # get samples\n",
    "# samples.append(ss)\n",
    "\n",
    "def callback(ss, obj):\n",
    "    samples.append(ss)\n",
    "    #obj.cancel_read_async()\n",
    "\n",
    "N_samples = sample_rate*0.5 # approximately seconds\n",
    "sdr.read_samples_async(limit_time(record_len)(callback), N_samples)   # get samples\n",
    "\n",
    "sdr_samples = np.hstack(samples)\n",
    "    \n",
    "# must wait for the queue to empty before terminating pyaudio\n",
    "while not(Qout.empty()) :\n",
    "    time.sleep(1)\n",
    "    \n",
    "\n",
    "p.terminate()# kill a playing thread"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# _ = myspectrogram_hann_ovlp(sdr_samples, 2048, sample_rate, center_freq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def demodulate(sdr_samples, sample_rate, ignore=0):\n",
    "    t = np.arange(len(sdr_samples)) / sample_rate\n",
    "    demod = np.exp(-2j*pi*freq_offset*t)\n",
    "    y = sdr_samples * demod\n",
    "\n",
    "    threshold = 0.04\n",
    "    y = y[abs(y) > threshold]\n",
    "\n",
    "    from scipy import signal  #should be imported already?\n",
    "\n",
    "    sig = angle(y[1:] * conj(y[:-1]))\n",
    "\n",
    "    h = signal.firwin(256,4000.0,nyq=sample_rate/2.0)\n",
    "    sigf = signal.fftconvolve(sig, h)\n",
    "    if ignore > 0:\n",
    "        sigf = sigf[ignore:-ignore]\n",
    "    \n",
    "    \n",
    "    downsample = 30\n",
    "    sigfd = sigf[::downsample]\n",
    "\n",
    "    fs_down = fs\n",
    "    sigfdd = signal.resample(sigfd, len(sigfd) * float(fs_down) / (sample_rate / float(downsample)))\n",
    "    \n",
    "    return sigfdd\n",
    "\n",
    "def smart_demod(sdr_samples, sample_rate, chunk_len = 10240):\n",
    "    t = np.arange(len(sdr_samples)) / sample_rate\n",
    "    demod = np.exp(-2j*pi*freq_offset*t)\n",
    "    y = sdr_samples * demod\n",
    "\n",
    "    threshold = 0.04\n",
    "    y = y[abs(y) > threshold]\n",
    "\n",
    "    from scipy import signal  #should be imported already?\n",
    "\n",
    "    sig = angle(y[1:] * conj(y[:-1]))\n",
    "\n",
    "    h = signal.firwin(256,4000.0,nyq=sample_rate/2.0)\n",
    "    sigf = signal.fftconvolve(sig, h)\n",
    "    \n",
    "    downsample = 30\n",
    "    sigfd = sigf[::downsample]\n",
    "    \n",
    "    result = np.array([])\n",
    "    pad = 1024\n",
    "    \n",
    "    scale = float(fs) / (sample_rate / float(downsample))\n",
    "    \n",
    "    for i in xrange(pad, len(sigfd), chunk_len):\n",
    "        s = sigfd[i-pad:i+chunk_len+pad]\n",
    "        r = signal.resample(s, len(s) * scale)\n",
    "        result = np.append(result, r[pad*scale:-pad*scale])\n",
    "    \n",
    "    return result\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ss = smart_demod(sdr_samples, sample_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "figure()\n",
    "wsize = 512\n",
    "dbf = 20\n",
    "_ = myspectrogram_hann_ovlp(ss, wsize, fs, 0, dbf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "errors\n",
      "1\n",
      "[('replace', 4799, 4799)]\n",
      "1\n",
      "[('replace', 4799, 4799)]\n",
      "1\n",
      "[('replace', 4799, 4799)]\n",
      "1\n",
      "[('replace', 4799, 4799)]\n",
      "1\n",
      "[('replace', 4799, 4799)]\n"
     ]
    }
   ],
   "source": [
    "import Levenshtein as leven\n",
    "\n",
    "packets = findPackets(ss)[0]\n",
    "print(len(packets))\n",
    "\n",
    "print('errors')\n",
    "for i in range(len(packets)):\n",
    "    pp = packets[i]\n",
    "    decoded = decodePacket(pp)\n",
    "\n",
    "    ds = ''.join([str(int(x)) for x in decoded])\n",
    "    bs = ''.join([str(int(x)) for x in bits])\n",
    "\n",
    "    dist = leven.distance(bs, ds)\n",
    "    print(dist)\n",
    "#     print(100 * float(dist) / Nbits)\n",
    "    print(leven.editops(bs, ds)[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}