From ee61e3f582cb400a66be85d2bd4cb0570ba24b9b Mon Sep 17 00:00:00 2001
From: Russ Handorf <rhandorf@handorf.org>
Date: Sat, 13 Feb 2016 16:14:55 -0500
Subject: [PATCH] Added files, directories and comments.

---
 README                             |  47 +++++
 sdrninja-client/sdr.html           |   2 +
 sdrninja-client/sdr.js             | 144 ++++++++++++++++
 sdrninja-client/sdrninja.init      |  47 +++++
 sdrninja-client/sdrninja/server.py | 110 ++++++++++++
 sdrninja-client/sdrninja/start.sh  |   4 +
 sdrninja-server/.waterfall.py.swp  | Bin 0 -> 16384 bytes
 sdrninja-server/client.py          | 267 +++++++++++++++++++++++++++++
 sdrninja-server/radio_math.py      | 204 ++++++++++++++++++++++
 sdrninja-server/radio_math.pyc     | Bin 0 -> 7648 bytes
 sdrninja-server/sdrninja.initd     |  47 +++++
 sdrninja-server/start.sh           |   4 +
 12 files changed, 876 insertions(+)
 create mode 100644 sdrninja-client/sdr.html
 create mode 100644 sdrninja-client/sdr.js
 create mode 100755 sdrninja-client/sdrninja.init
 create mode 100644 sdrninja-client/sdrninja/server.py
 create mode 100755 sdrninja-client/sdrninja/start.sh
 create mode 100644 sdrninja-server/.waterfall.py.swp
 create mode 100644 sdrninja-server/client.py
 create mode 100644 sdrninja-server/radio_math.py
 create mode 100644 sdrninja-server/radio_math.pyc
 create mode 100755 sdrninja-server/sdrninja.initd
 create mode 100755 sdrninja-server/start.sh

diff --git a/README b/README
index e69de29..ebfa13b 100644
--- a/README
+++ b/README
@@ -0,0 +1,47 @@
+Howdy do neighbor!
+
+If you're reading this, then pour yourself a tasty beverage. The history of this was so that I could learn the basics of websockets, html js canvasas, integration with wordpress, and some python coding for rtlsdr bits. All the code contained within is basically what you would need to do in order to mimic what is live on http://sdr.ninja.
+
+Firstly, lets get the licensing out of the way...
+
+###############################################################################
+# The MIT License (MIT)
+# Copyright (c) Russell Handorf
+# Other copyrights noted where code modification is located
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+In all cases for scripts, replace all instances of 'YOURSERVER' with your server's domainname, ip, or some other identifier. To make your life easier, just grep for this.
+
+sdrninja-client
+-sdr.html : This is the HTML code for your web page to include the canvas
+-sdr.js : This is the JS that is called to connect to the websocket and render the canvas. This has a YOURSERVER config requirement.
+-sdrninja.init : This is an init.d script for making it an automagical process if you'd like. Copy the sdrninja dir into /etc/ to make that happen more easily
+-sdrninja/start.sh : This is the script that the init script calls
+-sdrninja/server.py : This is what creates the python websocket. You'll have some dependencies to install laddy!
+-sdrninja/logs : If you want logs, dump 'em here
+
+sdrninja-server
+-client.py : A fairly modified script origionally written by Tavendo GmbH. I've added web socket handling, frequency range mapping, and a few other minor fixes to make this work. This is a great script to learn from for doing basif FFT in python. Tip of the hat to Tavendo GmbH!
+-radio_math.py/radio_math.pyc : Math dependencies for client.py. Tau for the win.
+-sdrninja.init : This is an init.d script for making it an automagical process if you'd like. Copy the sdrninja dir into /etc/ to make that happen more easily
+-logs : If you want logs, dump 'em here
+
diff --git a/sdrninja-client/sdr.html b/sdrninja-client/sdr.html
new file mode 100644
index 0000000..97489d7
--- /dev/null
+++ b/sdrninja-client/sdr.html
@@ -0,0 +1,2 @@
+<canvas id="sdr" height="48" width="1260" style="vertical-align: bottom" alt="SDR Ninja"></canvas>
+<script src="/js/sdr.js"></script>
diff --git a/sdrninja-client/sdr.js b/sdrninja-client/sdr.js
new file mode 100644
index 0000000..236b4e9
--- /dev/null
+++ b/sdrninja-client/sdr.js
@@ -0,0 +1,144 @@
+var canvas = document.getElementById("sdr");
+var canvasWidth = canvas.width;
+var canvasHeight = canvas.height;
+var ctx = canvas.getContext("2d");
+
+ctx.imageSmoothingEnabled = false;
+ctx.mozImageSmoothingEnabled = false;
+var canvasData = ctx.getImageData(0, 0, canvasWidth, canvasHeight);
+
+//test
+var buffer = document.createElement('canvas');
+buffer.width = canvas.width;
+buffer.height = canvas.height;
+
+
+//init pixels
+var pixels = new Array(canvasHeight*canvasWidth);
+
+//generate static
+var pixelCounter=0;
+
+for (y=0; y<canvasHeight; y++) {
+  for (x=0; x<canvasWidth; x++) {
+    //console.log("y:" + y + " x: " + x);
+    r=Math.floor((Math.random() * 255) + 1);
+    g=Math.floor((Math.random() * 255) + 1);
+    b=Math.floor((Math.random() * 255) + 1);
+    pixels[pixelCounter]={x:x, y:y, r:r, g:g, b:b};
+    pixelCounter++;
+  }
+}
+
+//convert static to json
+var pixelJSON = JSON.stringify(pixels);
+var obj = JSON.parse(pixelJSON);
+var arr = new Array();
+
+for(var x in obj){
+  arr.push(obj[x]);
+}
+
+
+var socket = null;
+var isopen = false;
+
+
+socket = new WebSocket("ws://YOURSERVER:9000");
+//socket.binaryType = "arraybuffer";
+
+socket.onopen = function() {
+   console.log("Connected!");
+   isopen = true;
+   sendText();
+}
+
+socket.onmessage = function(e) {
+   //console.log(e.data);
+   if (typeof e.data == "string") {
+     animate(e.data);
+   } else {
+      var arr = new Uint8Array(e.data);
+      var hex = '';
+      for (var i = 0; i < arr.length; i++) {
+         hex += ('00' + arr[i].toString(16)).substr(-2);
+      }
+      //console.log("Binary message received: " + hex);
+   }
+}
+
+socket.onclose = function(e) {
+   console.log("Connection closed.");
+   socket = null;
+   isopen = false;
+}
+
+function sendText() {
+  if (isopen) {
+     //socket.send(canvasWidth);
+     //console.log("Text message sent.");
+  } else {
+     console.log("Connection not opened.")
+  }
+};
+
+startStatic();
+
+function startStatic() {
+  //draw existing array
+  for (var x=0; x<((arr.length)); x++) {
+    drawPixel(arr[x].x, arr[x].y, arr[x].r, arr[x].g, arr[x].b, 255);
+  }
+  updateCanvas();
+}
+
+function animate(newrowJSON) {
+  //draw existing array
+  for (var x=0; x<((arr.length)); x++) {
+    drawPixel(arr[x].x, arr[x].y, arr[x].r, arr[x].g, arr[x].b, 255);
+  }
+  updateCanvas();
+  //shift everything down
+  for (var x=(arr.length-1); x>canvasWidth; x--) {
+    var offset = x-canvasWidth;
+    arr[x].r = arr[offset].r;
+    arr[x].g = arr[offset].g;
+    arr[x].b = arr[offset].b;
+  }
+  //insert the new row
+  var newrow = JSON.parse(newrowJSON);
+  padding=(canvasWidth-newrow.length)/2;
+  for (var x=0; x<padding; x++) {
+    arr[x].r = 0;
+    arr[x].g = 0;
+    arr[x].b = 100;
+  }
+  for (var x=padding; x<(newrow.length+padding); x++) {
+    //console.log(padding);
+    arr[x].r = newrow[x-padding].r;
+    arr[x].g = newrow[x-padding].g;
+    arr[x].b = newrow[x-padding].b;
+  }
+  for (var x=(newrow.length+padding); x<canvasWidth; x++) {
+    arr[x].r = 0;
+    arr[x].g = 0;
+    arr[x].b = 100;
+  }
+}
+
+function updateCanvas() {
+  ctx.save();
+  ctx.putImageData(canvasData, 0, 0);
+  ctx.restore();
+}
+
+//define the value of a pixel
+function drawPixel (x, y, r, g, b, a) {
+  var index = (x + y * canvasWidth) * 4;
+
+  canvasData.data[index + 0] = r;
+  canvasData.data[index + 1] = g;
+  canvasData.data[index + 2] = b;
+  canvasData.data[index + 3] = a;
+}
+
diff --git a/sdrninja-client/sdrninja.init b/sdrninja-client/sdrninja.init
new file mode 100755
index 0000000..0c21e7f
--- /dev/null
+++ b/sdrninja-client/sdrninja.init
@@ -0,0 +1,47 @@
+#! /bin/sh
+
+### BEGIN INIT INFO
+# Provides:          sdrninja
+# Required-Start:	$remote_fs $syslog
+# Required-Stop:	$remote_fs $syslog
+# Default-Start:	2 3 4 5
+# Default-Stop:		
+# Short-Description: sdrninja
+# Description: SDRNINJA
+### END INIT INFO
+
+#N=/etc/init.d/sdrninja
+
+PATH=/bin:/usr/bin:/sbin:/usr/sbin
+DAEMON=/etc/sdrninja/start.sh
+PIDFILE=/var/run/sdrninja.pid
+
+test -x $DAEMON || exit 0
+
+. /lib/lsb/init-functions
+
+case "$1" in
+  start)
+     log_daemon_msg "Starting sdrninja"
+     start_daemon -p $PIDFILE $DAEMON
+     log_end_msg $?
+   ;;
+  stop)
+     log_daemon_msg "Stopping sdrninja"
+     killproc -p $PIDFILE $DAEMON
+     PID=`ps x |grep feed | head -1 | awk '{print $1}'`
+     kill -9 $PID       
+     log_end_msg $?
+   ;;
+  force-reload|restart)
+     $0 stop
+     $0 start
+   ;;
+ *)
+   echo "Usage: /etc/init.d/sdrninja {start|stop|restart|force-reload}"
+   exit 1
+  ;;
+esac
+
+exit 0
+
diff --git a/sdrninja-client/sdrninja/server.py b/sdrninja-client/sdrninja/server.py
new file mode 100644
index 0000000..2b434f5
--- /dev/null
+++ b/sdrninja-client/sdrninja/server.py
@@ -0,0 +1,110 @@
+from random import randint
+import json, time
+
+import sys
+
+from twisted.internet import reactor
+from twisted.python import log
+from twisted.web.server import Site
+from twisted.web.static import File
+
+from autobahn.twisted.websocket import WebSocketServerFactory, \
+    WebSocketServerProtocol, \
+    listenWS
+
+
+class BroadcastServerProtocol(WebSocketServerProtocol):
+
+    def onOpen(self):
+        self.factory.register(self)
+
+    def onMessage(self, payload, isBinary):
+        if not isBinary:
+            #msg = "{} from {}".format(payload.decode('utf8'), self.peer)
+	    msg=format(payload.decode('utf8'))
+            #print self.peer
+            if (format(self.peer).find("192.168.5.84")):
+                self.factory.broadcast(msg)
+
+    def connectionLost(self, reason):
+        WebSocketServerProtocol.connectionLost(self, reason)
+        self.factory.unregister(self)
+
+
+class BroadcastServerFactory(WebSocketServerFactory):
+
+    """
+    Simple broadcast server broadcasting any message it receives to all
+    currently connected clients.
+    """
+
+    def __init__(self, url, debug=False, debugCodePaths=False):
+        WebSocketServerFactory.__init__(self, url, debug=debug, debugCodePaths=debugCodePaths)
+        self.clients = []
+	self.canvasWidth = 1260
+        #self.randomrow()
+
+    #def randomrow(self):
+        #row=[None]*self.canvasWidth
+        #for x in range (0,self.canvasWidth):
+        #  r=randint(0,255)
+        #  g=randint(0,255)
+        #  b=randint(0,255)
+        #  row[x]={"r": r, "g": g, "b": b}
+        #self.broadcast(json.dumps(row))
+        #reactor.callLater(0.1, self.randomrow)
+        ##return(json.dumps(row))
+
+    def register(self, client):
+        if client not in self.clients:
+            print("registered client {}".format(client.peer))
+            self.clients.append(client)
+
+    def unregister(self, client):
+        if client in self.clients:
+            print("unregistered client {}".format(client.peer))
+            self.clients.remove(client)
+
+    def broadcast(self, msg):
+        #print("broadcasting message '{}' ..".format(msg))
+        for c in self.clients:
+            c.sendMessage(msg.encode('utf8'))
+            #print("message sent to {}".format(c.peer))
+
+
+class BroadcastPreparedServerFactory(BroadcastServerFactory):
+
+    """
+    Functionally same as above, but optimized broadcast using
+    prepareMessage and sendPreparedMessage.
+    """
+
+    def broadcast(self, msg):
+        print("broadcasting prepared message '{}' ..".format(msg))
+        preparedMsg = self.prepareMessage(msg)
+        for c in self.clients:
+            c.sendPreparedMessage(preparedMsg)
+            print("prepared message sent to {}".format(c.peer))
+
+
+if __name__ == '__main__':
+
+    if len(sys.argv) > 1 and sys.argv[1] == 'debug':
+        log.startLogging(sys.stdout)
+        debug = True
+    else:
+        debug = False
+
+    ServerFactory = BroadcastServerFactory
+    # ServerFactory = BroadcastPreparedServerFactory
+
+    factory = ServerFactory("ws://localhost:9000",
+                            debug=debug,
+                            debugCodePaths=debug)
+
+    factory.protocol = BroadcastServerProtocol
+    factory.setProtocolOptions(allowHixie76=True)
+    listenWS(factory)
+
+    reactor.run()
+
diff --git a/sdrninja-client/sdrninja/start.sh b/sdrninja-client/sdrninja/start.sh
new file mode 100755
index 0000000..88bf935
--- /dev/null
+++ b/sdrninja-client/sdrninja/start.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+PWD=`pwd`
+script=$PWD'/server.py'
+/usr/bin/python $script &
diff --git a/sdrninja-server/.waterfall.py.swp b/sdrninja-server/.waterfall.py.swp
new file mode 100644
index 0000000000000000000000000000000000000000..b1af671ff6ec21abec586bb0b0fb7aade2c24122
GIT binary patch
literal 16384
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

literal 0
HcmV?d00001

diff --git a/sdrninja-server/client.py b/sdrninja-server/client.py
new file mode 100644
index 0000000..beda7a0
--- /dev/null
+++ b/sdrninja-server/client.py
@@ -0,0 +1,267 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) Tavendo GmbH
+# Modified by Russell Handorf
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+import json, time
+import sys, math, ctypes, numpy
+
+from rtlsdr import *
+from itertools import *
+from radio_math import *
+import operator
+
+from numpy import mean
+from random import randint
+from twisted.internet import reactor
+from autobahn.twisted.websocket import WebSocketClientFactory, \
+    WebSocketClientProtocol, \
+    connectWS
+
+class SdrWrap(object):
+    "wrap sdr and try to manage tuning"
+    def __init__(self):
+        self.sdr = RtlSdr()
+        self.read_samples = self.sdr.read_samples
+        self.prev_fc = None
+        self.prev_fs = None
+        self.prev_g  = 19
+        self.sdr.gain = 19
+    def tune(self, fc, fs, g):
+        if fc == self.prev_fc and fs == self.prev_fs and g == self.prev_g:
+            return
+        if fc != self.prev_fc:
+            self.sdr.center_freq = fc
+        if fs != self.prev_fs:
+            self.sdr.sample_rate = fs
+        if g != self.prev_g:
+            self.sdr.gain = g
+        self.prev_fc = fc
+        self.prev_fs = fs
+        self.prev_g  = g
+        time.sleep(0.04)  # wait for settle
+        self.sdr.read_samples(2**11)  # clear buffer
+        configure_highlight()
+    def gain_change(self, x):
+        # the whole 10x gain number is annoying
+        real_g = int(self.prev_g * 10)
+        i = self.sdr.GAIN_VALUES.index(real_g)
+        i += x
+        i = min(len(self.sdr.GAIN_VALUES) -1, i)
+        i = max(0, i)
+        new_g = self.sdr.GAIN_VALUES[i]
+        self.sdr.gain = new_g / 10.0
+        self.prev_g   = new_g / 10.0
+
+sdr = SdrWrap()
+
+class Stateful(object):
+    "bucket of globals"
+    def __init__(self):
+        self.freq_lower = None
+        self.freq_upper = None
+        self.vertexes   = []   # (timestamp, vertex_list)
+        self.batches    = []
+        self.time_start = None
+        self.viewport   = None
+        self.history    = 60   # seconds
+        self.fps        = 10
+        self.focus      = False
+        self.hover      = 0
+        self.highlight  = False
+        self.hl_mode    = None  # set this to a function!
+        self.hl_lo      = None
+        self.hl_hi      = None
+        self.hl_filter  = None
+        self.hl_pixels  = None
+	self.width	= 1260
+	self.shiftfreq	= time.time() +10
+
+state = Stateful()
+
+#state.freq_lower = float(929e6)
+#state.freq_upper = float(930e6)
+state.freq_lower = float(100e6)
+state.freq_upper = float(101e6)
+state.time_start = time.time()
+state.viewport = (0,0,1,1)
+
+def x_to_freq(x):
+    vp = state.viewport
+    delta = state.freq_upper - state.freq_lower
+    return delta * x / state.width + state.freq_lower
+
+def log2(x):
+    return math.log(x)/math.log(2)
+
+def acquire_sample(center, bw, detail, samples=8, relay=None):
+    "collect a single frequency"
+    assert bw <= 2.8e6
+    if detail < 8:
+        detail = 8
+    sdr.tune(center, bw, sdr.prev_g)
+    detail = 2**int(math.ceil(log2(detail)))
+    sample_count = samples * detail
+    data = sdr.read_samples(sample_count)
+    ys,xs = psd(data, NFFT=detail, Fs=bw/1e6, Fc=center/1e6)
+    ys = 10 * numpy.log10(ys)
+    if relay:
+        relay(data)
+    return xs, ys
+
+def mapping(x):
+    "assumes -50 to 0 range, returns color"
+    r = int((x+50) * 255 // 50)
+    r = max(0, r)
+    r = min(255, r)
+    return r,r,100
+
+def render_sample(now, dt, freqs, powers):
+    #quads = []
+    #colors = []
+    #row = [None]*4096
+    #interval = int(round(4096/state.width)+1)
+    interval = int(round(4096/state.width))
+    row = [None]*(1024)
+    temp=0
+    counter = 0
+    avgrgb=tuple([0,0,0])
+
+    #server side centering
+    #pad = (((4096-state.width)/interval)/interval)/interval
+    #for temp in range(0,pad):
+    #    row[temp]={"r": 0, "g": 0, "b": 100}
+
+    #temp=pad
+
+    for i,f in enumerate(freqs):
+        rgb = mapping(powers[i])
+        if (counter < interval):
+            avgrgb=tuple(map(operator.add, avgrgb, rgb))
+            #print "added {0}".format(rgb)
+            #print "sum {0}".format(avgrgb)
+            counter+=1
+        else:
+            #print "sum {0}".format(avgrgb)
+            #avgrgb=tuple(map(mean, zip(avgrgb)))
+            avgrgb=tuple(x/interval for x in avgrgb)
+            avgrgb=tuple(map(int, avgrgb))
+            #print "average {0}".format(avgrgb)
+            if (temp<(state.width+1)): 
+                row[temp]={"r": avgrgb[0], "g": avgrgb[1], "b": avgrgb[2]}
+            temp+=1
+            counter=0
+            avgrgb=tuple([0,0,0])
+            #print temp
+            #print "reset {0}".format(avgrgb)
+        #row[i]={"r": rgb[0], "g": rgb[1], "b": rgb[2]}
+
+    #server side centering
+    #for tmp in range(0,(state.width-temp)):
+    #    row[temp+tmp]={"r": 0, "g": 0, "b": 100}
+
+    return(json.dumps(row).encode('utf8'))
+    #self.sendMessage(json.dumps(row).encode('utf8'))
+    #return(json.dumps(row))
+
+def acquire_range(lower, upper):
+    "automatically juggles frequencies"
+    delta  = upper - lower
+    center = (upper+lower)/2
+    #if delta < 1.4e6:
+    if delta < 2.8e6:
+        # single sample
+        return acquire_sample(center, 2.8e6,
+            detail=state.width*2.8e6/delta,
+            relay=state.hl_mode)
+    xs2 = numpy.array([])
+    ys2 = numpy.array([])
+    detail = state.width // ((delta)/(2.8e6))
+    for f in range(int(lower), int(upper), int(2.8e6)):
+        xs,ys = acquire_sample(f+1.4e6, 2.8e6, detail=detail)
+        xs2 = numpy.append(xs2, xs)
+        ys2 = numpy.append(ys2, ys)
+    return xs2, ys2
+
+def configure_highlight():
+    if not state.highlight:
+        return
+    pass_fc = (state.hl_lo + state.hl_hi) / 2
+    pass_bw = state.hl_hi - state.hl_lo
+    if pass_bw == 0:
+        return
+    state.hl_filter = Bandpass(sdr.prev_fc, sdr.prev_fs,
+                               pass_fc, pass_bw)
+
+class BroadcastClientProtocol(WebSocketClientProtocol):
+
+    """
+    Simple client that connects to a WebSocket server, send a HELLO
+    message every 2 seconds and print everything it receives.
+    """
+    canvasWidth = 1260
+
+    def randomrow(self):
+        row=[None]*self.canvasWidth
+        for x in range (0,self.canvasWidth):
+          r=randint(0,255)
+          g=randint(0,255)
+          b=randint(0,255)
+          row[x]={"r": r, "g": g, "b": b}
+        #print(json.dumps(row).encode('utf8'))
+        self.sendMessage(json.dumps(row).encode('utf8'))
+        reactor.callLater(1, self.randomrow)
+        #return(json.dumps(row))
+
+    def update(self):
+        now = time.time() - state.time_start
+	if (state.shiftfreq < time.time()):
+            state.shiftfreq = time.time()+20
+            #state.freq_lower = randint(24e6,1766e6)
+            state.freq_lower = randint(80e6,105e6)
+            state.freq_upper = state.freq_lower + 1e6
+            #print "jumping frequency to {0}".format(state.freq_lower)
+	dt = 1.0/state.fps
+        freqs,power = acquire_range(state.freq_lower, state.freq_upper)
+        self.sendMessage(render_sample(now, dt, freqs, power))
+        reactor.callLater(0.1, self.update)
+
+    def onOpen(self):
+	#self.randomrow()
+	self.update()
+
+
+if __name__ == '__main__':
+
+    if len(sys.argv) < 2:
+        print("Need the WebSocket server address, i.e. ws://localhost:9000")
+        sys.exit(1)
+
+    factory = WebSocketClientFactory(sys.argv[1]) 
+    #factory = WebSocketClientFactory("ws://localhost:9000")
+    factory.protocol = BroadcastClientProtocol
+    connectWS(factory)
+
+    reactor.run()
diff --git a/sdrninja-server/radio_math.py b/sdrninja-server/radio_math.py
new file mode 100644
index 0000000..00612f1
--- /dev/null
+++ b/sdrninja-server/radio_math.py
@@ -0,0 +1,204 @@
+#! /usr/bin/env python2
+
+from itertools import *
+import math, numpy
+
+tau = 2 * math.pi
+
+class Translate(object):
+    "set up once, consumes an I/Q stream, returns an I/Q stream"
+    def __init__(self, num, den):
+        angles = [(a*tau*num/den) % tau for a in range(den)]
+        fir = [complex(math.cos(a), math.sin(a)) for a in angles]
+        self.looping_fir = cycle(fir)
+    def __call__(self, stream):
+        return numpy.array([s1*s2 for s1,s2 in izip(self.looping_fir, stream)])
+
+class Downsample(object):
+    "set up once, consumes an I/Q stream, returns an I/Q stream"
+    # aka lowpass
+    def __init__(self, scale):
+        self.scale = scale
+        self.offset = 0
+        self.window = numpy.hanning(scale * 2)
+        self.window = self.window / sum(self.window)
+    def __call__(self, stream):
+        prev_off = self.offset
+        self.offset = self.scale - ((len(stream) + self.offset) % self.scale)
+        # bad edges, does 60x more math than needed
+        stream2 = numpy.convolve(stream, self.window)
+        return stream2[prev_off::self.scale]
+
+class DownsampleFloat(object):
+    # poor quality, but good temporal accuracy
+    # uses triangle window
+    def __init__(self, scale):
+        self.scale = scale
+        self.offset = 0
+    def __call__(self, stream):
+        # bad edges
+        # should be using more numpy magic
+        scale = self.scale
+        stream2 = []
+        for x in numpy.arange(self.offset, len(stream), scale):
+            frac = x % 1.0
+            window = numpy.concatenate((numpy.arange(1-frac, scale),
+                     numpy.arange(int(scale)+frac-1, 0, -1)))
+            window = window / sum(window)
+            start = x - len(window)//2
+            start = max(start, 0)
+            start = min(start, len(stream)-len(window))
+            c = sum(stream[start : start+len(window)] * window)
+            stream2.append(c)
+        return numpy.array(stream2)
+
+class Upsample(object):
+    # use minimal power interpolation?
+    def __init__(self, scale):
+        self.scale = scale
+        self.offset = 0
+    def __call__(self, stream):
+        xp = range(len(stream))
+        x2 = numpy.arange(self.offset, len(stream), 1.0/self.scale)
+        self.offset = (len(stream) + self.offset) % self.scale
+        reals = numpy.interp(x2, xp, stream.real)
+        imags = numpy.interp(x2, xp, stream.imag)
+        return numpy.array([complex(*ri) for ri in zip(reals, imags)])
+
+class Bandpass(object):
+    "set up once, consumes an I/Q stream, returns an I/Q stream"
+    def __init__(self, center_fc, center_bw, pass_fc, pass_bw):
+        # some errors from dropping the fractional parts of the ratio
+        # either optimize tuning, scale up, or use floating point
+        ratio = (center_fc - pass_fc) / center_bw
+        self.translate = Translate(ratio * 1024, 1024)
+        self.downsample = Downsample(int(center_bw/pass_bw))
+    def __call__(self, stream):
+        return self.downsample(self.translate(stream))
+
+# check license on matplotlib code
+# chop out as much slow junk as possible
+
+# http://mail.scipy.org/pipermail/numpy-discussion/2003-January/014298.html
+# http://cleaver.cnx.rice.edu/eggs_directory/obspy.signal/obspy.signal/obspy/signal/freqattributes.py
+# /usr/lib/python2.7/site-packages/matplotlib/mlab.py
+
+def detrend_none(x):
+    "Return x: no detrending"
+    return x
+
+def window_hanning(x):
+    "return x times the hanning window of len(x)"
+    return numpy.hanning(len(x))*x
+
+def psd(x, NFFT=256, Fs=2, Fc=0, detrend=detrend_none, window=window_hanning,
+        noverlap=0, pad_to=None, sides='default', scale_by_freq=True):
+    Pxx,freqs = csd(x, x, NFFT, Fs, detrend, window, noverlap, pad_to, sides,
+        scale_by_freq)
+    return Pxx.real, freqs + Fc
+
+def csd(x, y, NFFT=256, Fs=2, detrend=detrend_none, window=window_hanning,
+        noverlap=0, pad_to=None, sides='default', scale_by_freq=True):
+    Pxy, freqs, t = _spectral_helper(x, y, NFFT, Fs, detrend, window,
+        noverlap, pad_to, sides, scale_by_freq)
+
+    if len(Pxy.shape) == 2 and Pxy.shape[1]>1:
+        Pxy = Pxy.mean(axis=1)
+    return Pxy, freqs
+
+
+#This is a helper function that implements the commonality between the
+#psd, csd, and spectrogram.  It is *NOT* meant to be used outside of mlab
+def _spectral_helper(x, y, NFFT=256, Fs=2, detrend=detrend_none,
+        window=window_hanning, noverlap=0, pad_to=None, sides='default',
+        scale_by_freq=True):
+    #The checks for if y is x are so that we can use the same function to
+    #implement the core of psd(), csd(), and spectrogram() without doing
+    #extra calculations.  We return the unaveraged Pxy, freqs, and t.
+    same_data = y is x
+
+    #Make sure we're dealing with a numpy array. If y and x were the same
+    #object to start with, keep them that way
+    x = numpy.asarray(x)
+    if not same_data:
+        y = numpy.asarray(y)
+    else:
+        y = x
+
+    # zero pad x and y up to NFFT if they are shorter than NFFT
+    if len(x)<NFFT:
+        n = len(x)
+        x = numpy.resize(x, (NFFT,))
+        x[n:] = 0
+
+    if not same_data and len(y)<NFFT:
+        n = len(y)
+        y = numpy.resize(y, (NFFT,))
+        y[n:] = 0
+
+    if pad_to is None:
+        pad_to = NFFT
+
+    # For real x, ignore the negative frequencies unless told otherwise
+    if (sides == 'default' and numpy.iscomplexobj(x)) or sides == 'twosided':
+        numFreqs = pad_to
+        scaling_factor = 1.
+    elif sides in ('default', 'onesided'):
+        numFreqs = pad_to//2 + 1
+        scaling_factor = 2.
+    else:
+        raise ValueError("sides must be one of: 'default', 'onesided', or "
+            "'twosided'")
+
+    #if cbook.iterable(window):
+    if type(window) != type(lambda:0):
+        assert(len(window) == NFFT)
+        windowVals = window
+    else:
+        windowVals = window(numpy.ones((NFFT,), x.dtype))
+
+    step = NFFT - noverlap
+    ind = numpy.arange(0, len(x) - NFFT + 1, step)
+    n = len(ind)
+    Pxy = numpy.zeros((numFreqs, n), numpy.complex_)
+
+    # do the ffts of the slices
+    for i in range(n):
+        thisX = x[ind[i]:ind[i]+NFFT]
+        thisX = windowVals * detrend(thisX)
+        fx = numpy.fft.fft(thisX, n=pad_to)
+
+        if same_data:
+            fy = fx
+        else:
+            thisY = y[ind[i]:ind[i]+NFFT]
+            thisY = windowVals * detrend(thisY)
+            fy = numpy.fft.fft(thisY, n=pad_to)
+        Pxy[:,i] = numpy.conjugate(fx[:numFreqs]) * fy[:numFreqs]
+
+    # Scale the spectrum by the norm of the window to compensate for
+    # windowing loss; see Bendat & Piersol Sec 11.5.2.
+    Pxy /= (numpy.abs(windowVals)**2).sum()
+
+    # Also include scaling factors for one-sided densities and dividing by the
+    # sampling frequency, if desired. Scale everything, except the DC component
+    # and the NFFT/2 component:
+    Pxy[1:-1] *= scaling_factor
+
+    # MATLAB divides by the sampling frequency so that density function
+    # has units of dB/Hz and can be integrated by the plotted frequency
+    # values. Perform the same scaling here.
+    if scale_by_freq:
+        Pxy /= Fs
+
+    t = 1./Fs * (ind + NFFT / 2.)
+    freqs = float(Fs) / pad_to * numpy.arange(numFreqs)
+
+    if (numpy.iscomplexobj(x) and sides == 'default') or sides == 'twosided':
+        # center the frequency range at zero
+        freqs = numpy.concatenate((freqs[numFreqs//2:] - Fs, freqs[:numFreqs//2]))
+        Pxy = numpy.concatenate((Pxy[numFreqs//2:, :], Pxy[:numFreqs//2, :]), 0)
+
+    return Pxy, freqs, t
+
+
diff --git a/sdrninja-server/radio_math.pyc b/sdrninja-server/radio_math.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fbe981e551161c9ad6db7dcd4ffcbbe1e17f2d8
GIT binary patch
literal 7648
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
C&ZLL{

literal 0
HcmV?d00001

diff --git a/sdrninja-server/sdrninja.initd b/sdrninja-server/sdrninja.initd
new file mode 100755
index 0000000..8626e46
--- /dev/null
+++ b/sdrninja-server/sdrninja.initd
@@ -0,0 +1,47 @@
+#! /bin/sh
+
+### BEGIN INIT INFO
+# Provides:          sdrninja
+# Required-Start:    $local_fs $remote_fs
+# Required-Stop:
+# X-Start-Before:    rmnologin
+# Default-Start:     2 3 4 5
+# Default-Stop:
+# Short-Description: sdrninja
+# Description: SDRNINJA
+### END INIT INFO
+
+#N=/etc/init.d/sdrninja
+
+PATH=/bin:/usr/bin:/sbin:/usr/sbin
+DAEMON=/etc/sdrninja/start.sh
+PIDFILE=/var/run/sdrninja.pid
+
+test -x $DAEMON || exit 0
+
+. /lib/lsb/init-functions
+
+case "$1" in
+  start)
+     log_daemon_msg "Starting sdrninja"
+     start_daemon -p $PIDFILE $DAEMON
+     log_end_msg $?
+   ;;
+  stop)
+     log_daemon_msg "Stopping sdrninja"
+     killproc -p $PIDFILE $DAEMON
+     PID=`ps x |grep feed | head -1 | awk '{print $1}'`
+     kill -9 $PID       
+     log_end_msg $?
+   ;;
+  force-reload|restart)
+     $0 stop
+     $0 start
+   ;;
+ *)
+   echo "Usage: /etc/init.d/sdrninja {start|stop|restart|force-reload}"
+   exit 1
+  ;;
+esac
+
+exit 0
diff --git a/sdrninja-server/start.sh b/sdrninja-server/start.sh
new file mode 100755
index 0000000..b2cabef
--- /dev/null
+++ b/sdrninja-server/start.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+PWD=`pwd`
+script=$PWD'/client.py ws://YOURSERVER:9000'
+/usr/bin/python $script &
-- 
2.17.1