Repo re-org

28 files changed, 7578 insertions, 0 deletions

diff --git a/hardware/fw/.gitignore b/hardware/fw/.gitignore
new file mode 100644
index 0000000..0a0c26e
--- /dev/null
+++ b/hardware/fw/.gitignore
@@ -0,0 +1,6 @@
+*.expand
+*.map
+*.lst
+*.hex
+*.elf
+*.bin
diff --git a/hardware/fw/Makefile b/hardware/fw/Makefile
new file mode 100644
index 0000000..77b2a09
--- /dev/null
+++ b/hardware/fw/Makefile
@@ -0,0 +1,111 @@
+# Megumin LED display firmware
+# Copyright (C) 2018 Sebastian Götte <code@jaseg.net>
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+CUBE_PATH 		?= $(wildcard ~)/resource/STM32CubeF0
+CMSIS_PATH 		?= $(CUBE_PATH)/Drivers/CMSIS
+CMSIS_DEV_PATH  ?= $(CMSIS_PATH)/Device/ST/STM32F0xx
+HAL_PATH   		?= $(CUBE_PATH)/Drivers/STM32F0xx_HAL_Driver
+
+MAC_ADDR        ?= 0xdeadbeef
+
+CC      := arm-none-eabi-gcc
+LD      := arm-none-eabi-ld
+OBJCOPY := arm-none-eabi-objcopy
+OBJDUMP := arm-none-eabi-objdump
+SIZE    := arm-none-eabi-size
+
+CFLAGS  = -g -Wall -Wextra -std=gnu11 -O0 -fdump-rtl-expand
+CFLAGS += -mlittle-endian -mcpu=cortex-m0 -march=armv6-m -mthumb
+#CFLAGS += -ffunction-sections -fdata-sections
+LDFLAGS = -nostartfiles
+#LDFLAGS += -specs=rdimon.specs -DSEMIHOSTING
+LDFLAGS += -Wl,-Map=main.map -nostdlib
+#LDFLAGS += -Wl,--gc-sections 
+LIBS = -lgcc
+#LIBS += -lrdimon
+
+# Technically we're using an STM32F030F4, but apart from the TSSOP20 package that one is largely identical to the
+# STM32F030*6 and there is no separate device header provided for it, so we're faking a *6 device here. This is
+# even documented in stm32f0xx.h. Thanks ST!
+CFLAGS += -DSTM32F030x6 -DHSE_VALUE=19440000
+
+LDFLAGS += -Tstm32_flash.ld
+CFLAGS += -I$(CMSIS_DEV_PATH)/Include -I$(CMSIS_PATH)/Include -I$(HAL_PATH)/Inc -Iconfig -Wno-unused -I../common
+LDFLAGS += -L$(CMSIS_PATH)/Lib/GCC -larm_cortexM0l_math
+
+###################################################
+
+.PHONY: program clean
+
+all: main.elf
+
+.clang:
+	echo flags = $(CFLAGS) > .clang 
+
+cmsis_exports.c: $(CMSIS_DEV_PATH)/Include/stm32f030x6.h $(CMSIS_PATH)/Include/core_cm0.h
+	python3 tools/gen_cmsis_exports.py $^ > $@
+
+%.o: %.c
+	$(CC) -c $(CFLAGS) -o $@ $^
+#	$(CC) -E $(CFLAGS) -o $(@:.o=.pp) $^
+
+%.o: %.s
+	$(CC) -c $(CFLAGS) -o $@ $^
+#	$(CC) -E $(CFLAGS) -o $(@:.o=.pp) $^
+
+%.dot: %.elf
+	r2 -a arm -qc 'aa;agC' $< 2>/dev/null >$@
+	
+sources.tar.xz: main.c Makefile
+	tar -caf $@ $^
+
+# don't ask...
+sources.tar.xz.zip: sources.tar.xz
+	zip $@ $^
+
+sources.c: sources.tar.xz.zip
+	xxd -i $< | head -n -1 | sed 's/=/__attribute__((section(".source_tarball"))) =/' > $@
+
+main.elf: main.c adc.c serial.c cobs.c startup_stm32f030x6.s system_stm32f0xx.c $(HAL_PATH)/Src/stm32f0xx_ll_utils.c base.c cmsis_exports.c
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
+	$(OBJCOPY) -O ihex $@ $(@:.elf=.hex)
+	$(OBJCOPY) -O binary $@ $(@:.elf=.bin)
+	$(OBJDUMP) -St $@ >$(@:.elf=.lst)
+	$(SIZE) $@
+	
+program: main.elf openocd.cfg
+	openocd -f openocd.cfg -c "program $< verify reset exit"
+
+8b10b_test_encode: 8b10b_test_encode.c 8b10b.c
+	gcc -o $@ $^
+
+8b10b_test_decode: 8b10b_test_decode.c 8b10b.c
+	gcc -o $@ $^
+
+protocol_test: protocol.c protocol_test.c
+	gcc -o $@ -O0 -Wall -Wextra -g -I../common $^
+
+clean:
+	rm -f **.o
+	rm -f main.elf main.hex main.bin main.map main.lst
+	rm -f **.expand
+	rm -f cmsis_exports.c
+	rm -f sources.tar.xz
+	rm -f sources.tar.xz.zip
+	rm -f sources.c
+	rm -f *.dot
+	rm -f protocol_test
+
diff --git a/hardware/fw/Scope.ipynb b/hardware/fw/Scope.ipynb
new file mode 100644
index 0000000..82898fd
--- /dev/null
+++ b/hardware/fw/Scope.ipynb
@@ -0,0 +1,906 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib import pyplot as plt\n",
+    "%matplotlib notebook\n",
+    "import numpy as np\n",
+    "import struct\n",
+    "import math"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_data(offx=0, end=-1, signed=False, channels=1):\n",
+    "    with open('/tmp/scope_dump.bin', 'rb') as f:\n",
+    "        raw_data = f.read()\n",
+    "        data = struct.unpack(f'<{len(raw_data)//2}{\"h\" if signed else \"H\"}', raw_data)\n",
+    "    \n",
+    "    fig, axs = plt.subplots(channels*2, 1, squeeze=False, sharex=True, figsize=(10, 5))\n",
+    "    axs = axs.flatten()\n",
+    "    for i, (ax_t, ax_f) in enumerate(zip(axs[0::2], axs[1::2])):\n",
+    "        le_slice = data[offx:][:end][i::channels]\n",
+    "        ax_t.plot(np.linspace(0, len(le_slice)/1000, len(le_slice)),\n",
+    "            [math.nan if x==-255 else x for x in le_slice])\n",
+    "        ax_t.grid()   \n",
+    "        \n",
+    "        ax_f.specgram(le_slice, Fs=1000)\n",
+    "        ax_f.grid()\n",
+    "                             \n",
+    "    return data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"1000\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = plot_data(offx=4, signed=True, channels=1)\n",
+    "#print(''.join(str(x) for x in data[4:][3::4]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: '/tmp/foo'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-32-d8e3fa510bf1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     13\u001b[0m     \u001b[0mplotdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvals\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mdelta\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mdelta\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdelta\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mplotdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mplot_avg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m<ipython-input-32-d8e3fa510bf1>\u001b[0m in \u001b[0;36mplot_avg\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mplot_avg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/tmp/foo'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m         \u001b[0mvals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrombuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'uint16'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/tmp/foo'"
+     ]
+    }
+   ],
+   "source": [
+    "import random, struct, numpy as np\n",
+    "\n",
+    "def plot_avg():\n",
+    "    with open('/tmp/foo', 'rb') as f:\n",
+    "        vals = np.frombuffer(f.read(), dtype='uint16')\n",
+    "    \n",
+    "    vals = vals.copy()\n",
+    "    idx = 1\n",
+    "    vals &= 1<<idx\n",
+    "    vals >>= idx\n",
+    "    \n",
+    "    delta = 10000\n",
+    "    plotdata = [sum(vals[i:i+delta])/delta for i in range(0, len(vals), delta)]\n",
+    "    plt.plot(plotdata)\n",
+    "plot_avg()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/hardware/fw/adc.c b/hardware/fw/adc.c
new file mode 100644
index 0000000..7e1b8cc
--- /dev/null
+++ b/hardware/fw/adc.c
@@ -0,0 +1,136 @@
+/* Megumin LED display firmware
+ * Copyright (C) 2018 Sebastian Götte <code@jaseg.net>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "adc.h"
+#include "serial.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <assert.h>
+
+static struct __attribute__((__packed__)) hl_adc_pkt {
+    struct ll_pkt ll;
+    uint16_t seq;
+    int32_t gps_1pps_period_sysclk;
+    volatile uint16_t data[32];
+} adc_pkt[2];
+static uint16_t current_seq = 0;
+static int current_buf = 0;
+
+static void adc_dma_init(void);
+static void adc_dma_launch(void);
+
+
+/* Mode that can be used for debugging */
+void adc_init() {
+	adc_dma_init();
+
+    /* Clock from PCLK/4 instead of the internal exclusive high-speed RC oscillator. */
+    ADC1->CFGR2 = (2<<ADC_CFGR2_CKMODE_Pos); /* Use PCLK/4=12MHz */
+    /* Sampling time 239.5 ADC clock cycles -> total conversion time 38.5us*/
+    ADC1->SMPR  = (7<<ADC_SMPR_SMP_Pos);
+
+	/* Setup DMA and triggering */
+	/* Trigger from TIM1 TRGO */
+    ADC1->CFGR1 = ADC_CFGR1_DMAEN | ADC_CFGR1_DMACFG | (2<<ADC_CFGR1_EXTEN_Pos) | (1<<ADC_CFGR1_EXTSEL_Pos);
+    ADC1->CHSELR = ADC_CHSELR_CHSEL2;
+	/* Perform self-calibration */
+    ADC1->CR |= ADC_CR_ADCAL;
+    while (ADC1->CR & ADC_CR_ADCAL)
+        ;
+	/* Enable conversion */
+    ADC1->CR |= ADC_CR_ADEN;
+    ADC1->CR |= ADC_CR_ADSTART;
+}
+
+static void adc_dma_init() {
+    /* Configure DMA 1 Channel 1 to get rid of all the data */
+    DMA1_Channel1->CPAR = (unsigned int)&ADC1->DR;
+    DMA1_Channel1->CCR = (0<<DMA_CCR_PL_Pos);
+    DMA1_Channel1->CCR |=
+          (1<<DMA_CCR_MSIZE_Pos) /* 16 bit */
+        | (1<<DMA_CCR_PSIZE_Pos) /* 16 bit */
+        | DMA_CCR_MINC
+        | DMA_CCR_TCIE; /* Enable transfer complete interrupt. */
+
+    /* triggered on half-transfer and on transfer completion. We use this to send out the ADC data and to trap into GDB. */
+    NVIC_EnableIRQ(DMA1_Channel1_IRQn);
+    NVIC_SetPriority(DMA1_Channel1_IRQn, 2<<5);
+
+    adc_dma_launch();
+}
+
+void adc_dma_launch() {
+    DMA1_Channel1->CCR &= ~DMA_CCR_EN; /* Disable channel */
+    current_buf = !current_buf;
+    DMA1_Channel1->CMAR = (unsigned int)&(adc_pkt[current_buf].data);
+    DMA1_Channel1->CNDTR = ARRAY_LEN(adc_pkt[current_buf].data);
+    DMA1_Channel1->CCR |= DMA_CCR_EN; /* Enable channel */
+}
+
+void adc_timer_init(int psc, int ivl) {
+    TIM1->BDTR  = TIM_BDTR_MOE; /* MOE is needed even though we only "output" a chip-internal signal */
+    TIM1->CCMR2 = (6<<TIM_CCMR2_OC4M_Pos); /* PWM Mode 1 to get a clean trigger signal */
+    TIM1->CCER  = TIM_CCER_CC4E; /* Enable capture/compare unit 4 connected to ADC */
+    TIM1->CCR4  = 1; /* Trigger at start of timer cycle */
+	/* Set prescaler and interval */
+    TIM1->PSC   = psc-1;
+    TIM1->ARR   = ivl-1;
+    /* Preload all values */
+    TIM1->EGR   = TIM_EGR_UG;
+    TIM1->CR1   = TIM_CR1_ARPE;
+    /* And... go! */
+    TIM1->CR1  |= TIM_CR1_CEN;
+}
+
+/* This acts as a no-op that provides a convenient point to set a breakpoint for the debug scope logic */
+static void gdb_dump(void) {
+}
+
+void DMA1_Channel1_IRQHandler(void) {
+    uint32_t isr = DMA1->ISR;
+    /* Clear the interrupt flag */
+    DMA1->IFCR |= DMA_IFCR_CGIF1;
+    adc_dma_launch();
+
+    gdb_dump();
+
+    adc_pkt[!current_buf].seq = current_seq++;
+    adc_pkt[!current_buf].gps_1pps_period_sysclk = gps_1pps_period_sysclk;
+    /* Ignore return value since we can't do anything here. Overruns are logged in serial.c. */
+    usart_send_packet_nonblocking(&adc_pkt[!current_buf].ll, sizeof(adc_pkt[!current_buf]));
+    
+    /*
+    static int debug_buf_pos = 0;
+    if (st->sync) {
+        if (debug_buf_pos < NCH) {
+                debug_buf_pos = NCH;
+        } else {
+            adc_buf[debug_buf_pos++] = symbol;
+
+            if (debug_buf_pos >= sizeof(adc_buf)/sizeof(adc_buf[0])) {
+                debug_buf_pos = 0;
+                st->sync = 0;
+                gdb_dump();
+                for (int i=0; i<sizeof(adc_buf)/sizeof(adc_buf[0]); i++)
+                    adc_buf[i] = -255;
+            }
+        }
+    }
+    */
+}
+
diff --git a/hardware/fw/adc.h b/hardware/fw/adc.h
new file mode 100644
index 0000000..cba18d1
--- /dev/null
+++ b/hardware/fw/adc.h
@@ -0,0 +1,26 @@
+/* Megumin LED display firmware
+ * Copyright (C) 2018 Sebastian Götte <code@jaseg.net>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ADC_H__
+#define __ADC_H__
+
+#include "global.h"
+
+void adc_init();
+void adc_timer_init(int psc, int ivl);
+
+#endif/*__ADC_H__*/
diff --git a/hardware/fw/base.c b/hardware/fw/base.c
new file mode 100644
index 0000000..8e7c03b
--- /dev/null
+++ b/hardware/fw/base.c
@@ -0,0 +1,25 @@
+
+#include <unistd.h>
+#include <stdbool.h>
+
+int __errno = 0;
+void *_impure_ptr = NULL;
+
+void __sinit(void) {
+}
+
+void *memset(void *s, int c, size_t n) {
+    char *end = (char *)s + n;
+    for (char *p = (char *)s; p < end; p++)
+        *p = (char)c;
+    return s;
+}
+
+size_t strlen(const char *s) {
+    const char *start = s;
+    while (*s++);
+    return s - start - 1;
+}
+
+void __assert_func(bool value) {
+}
diff --git a/hardware/fw/cmsis_exports.c b/hardware/fw/cmsis_exports.c
new file mode 100644
index 0000000..39874b5
--- /dev/null
+++ b/hardware/fw/cmsis_exports.c
@@ -0,0 +1,48 @@
+#ifndef __GENERATED_CMSIS_HEADER_EXPORTS__
+#define __GENERATED_CMSIS_HEADER_EXPORTS__
+
+#include <stm32f030x6.h>
+
+/* stm32f030x6.h */
+TIM_TypeDef *tim3 = TIM3;
+TIM_TypeDef *tim14 = TIM14;
+RTC_TypeDef *rtc = RTC;
+WWDG_TypeDef *wwdg = WWDG;
+IWDG_TypeDef *iwdg = IWDG;
+I2C_TypeDef *i2c1 = I2C1;
+PWR_TypeDef *pwr = PWR;
+SYSCFG_TypeDef *syscfg = SYSCFG;
+EXTI_TypeDef *exti = EXTI;
+ADC_TypeDef *adc1 = ADC1;
+ADC_Common_TypeDef *adc1_common = ADC1_COMMON;
+ADC_Common_TypeDef *adc = ADC;
+TIM_TypeDef *tim1 = TIM1;
+SPI_TypeDef *spi1 = SPI1;
+USART_TypeDef *usart1 = USART1;
+TIM_TypeDef *tim16 = TIM16;
+TIM_TypeDef *tim17 = TIM17;
+DBGMCU_TypeDef *dbgmcu = DBGMCU;
+DMA_TypeDef *dma1 = DMA1;
+DMA_Channel_TypeDef *dma1_channel1 = DMA1_Channel1;
+DMA_Channel_TypeDef *dma1_channel2 = DMA1_Channel2;
+DMA_Channel_TypeDef *dma1_channel3 = DMA1_Channel3;
+DMA_Channel_TypeDef *dma1_channel4 = DMA1_Channel4;
+DMA_Channel_TypeDef *dma1_channel5 = DMA1_Channel5;
+FLASH_TypeDef *flash = FLASH;
+OB_TypeDef *ob = OB;
+RCC_TypeDef *rcc = RCC;
+CRC_TypeDef *crc = CRC;
+GPIO_TypeDef *gpioa = GPIOA;
+GPIO_TypeDef *gpiob = GPIOB;
+GPIO_TypeDef *gpioc = GPIOC;
+GPIO_TypeDef *gpiod = GPIOD;
+GPIO_TypeDef *gpiof = GPIOF;
+
+#include <core_cm0.h>
+
+/* core_cm0.h */
+SCB_Type *scb = SCB;
+SysTick_Type *systick = SysTick;
+NVIC_Type *nvic = NVIC;
+
+#endif//__GENERATED_CMSIS_HEADER_EXPORTS__
diff --git a/hardware/fw/cobs.c b/hardware/fw/cobs.c
new file mode 100644
index 0000000..041dd8f
--- /dev/null
+++ b/hardware/fw/cobs.c
@@ -0,0 +1,212 @@
+
+#include "serial.h"
+#include "cobs.h"
+
+int cobs_encode_usart(int (*output)(char), char *src, size_t srclen) {
+    if (srclen > 254)
+        return -1;
+
+    size_t p = 0;
+    while (p <= srclen) {
+
+        char val;
+        if (p != 0 && src[p-1] != 0) {
+            val = src[p-1];
+
+        } else {
+            size_t q = p;
+            while (q < srclen && src[q] != 0)
+                q++;
+            val = (char)q-p+1;
+        }
+
+        int rv = output(val);
+        if (rv)
+            return rv;
+        p++;
+    }
+
+    int rv = output(0);
+    if (rv)
+        return rv;
+
+    return 0;
+}
+
+/*@ requires \valid(dst + (0..dstlen-1));
+  @ requires \valid_read(src + (0..srclen-1));
+  @ requires \separated(dst + (0..dstlen-1), src + (0..srclen-1));
+  @ 
+  @ behavior maybe_valid_frame:
+  @     assumes 1 <= srclen <= dstlen <= 65535;
+  @     assumes \exists integer j; j > 0 && \forall integer i; 0 <= i < j ==> src[i] != 0;
+  @     assumes \exists integer i; 0 <= i < srclen && src[i] == 0;
+  @     assigns dst[0..dstlen-1];
+  @     ensures \result >= 0 || \result == -3;
+  @     ensures \result >= 0 ==> src[\result+1] == 0;
+  @     ensures \result >= 0 ==> (\forall integer i; 0 <= i < \result ==> src[i] != 0);
+  @
+  @ behavior invalid_frame:
+  @     assumes 1 <= srclen <= dstlen <= 65535;
+  @     assumes src[0] == 0 || \forall integer i; 0 <= i < srclen ==> src[i] != 0;
+  @     assigns dst[0..dstlen-1];
+  @     ensures \result == -2;
+  @
+  @ behavior invalid_buffers:
+  @     assumes    dstlen < 0 || dstlen > 65535
+  @             || srclen < 1 || srclen > 65535
+  @             || dstlen < srclen;
+  @     assigns \nothing;
+  @     ensures \result == -1;
+  @
+  @ complete behaviors;
+  @ disjoint behaviors;
+  @*/
+ssize_t cobs_decode(char *dst, size_t dstlen, char *src, size_t srclen) {
+    if (dstlen > 65535 || srclen > 65535)
+        return -1;
+
+    if (srclen < 1)
+        return -1;
+
+    if (dstlen < srclen)
+        return -1;
+
+    size_t p = 1;
+    size_t c = (unsigned char)src[0];
+    //@ assert 0 <= c < 256;
+    //@ assert 0 <= c;
+    //@ assert c < 256;
+    if (c == 0)
+        return -2; /* invalid framing. An empty frame would be [...] 00 01 00, not [...] 00 00 */
+    //@ assert c >= 0;
+    //@ assert c != 0;
+    //@ assert c <= 257;
+    //@ assert c > 0;
+    //@ assert c >= 0 && c != 0 ==> c > 0;
+
+    /*@ //loop invariant \forall integer i; 0 <= i <= p ==> (i == srclen || src[i] != 0);
+      @ loop invariant \forall integer i; 1 <= i < p ==> src[i] != 0;
+      @ loop invariant c > 0;
+      @ loop invariant 1 <= p <= srclen <= dstlen <= 65535;
+      @ loop invariant \separated(dst + (0..dstlen-1), src + (0..srclen-1));
+      @ loop invariant \valid_read(src + (0..srclen-1));
+      @ loop invariant \forall integer i; 1 <= i <= srclen ==> \valid(dst + i - 1);
+      @ loop assigns dst[0..dstlen-1], p, c;
+      @ loop variant srclen-p;
+      @*/
+    while (p < srclen && src[p]) {
+        char val;
+        c--;
+
+        //@ assert src[p] != 0;
+        if (c == 0) {
+            c = (unsigned char)src[p];
+            val = 0;
+        } else {
+            val = src[p];
+        }
+
+        //@ assert 0 <= p-1 <= dstlen-1;
+        dst[p-1] = val;
+        p++;
+    }
+
+    if (p == srclen)
+        return -2; /* Invalid framing. The terminating null byte should always be present in the input buffer. */
+
+    if (c != 1)
+        return -3; /* Invalid framing. The skip counter does not hit the end of the frame. */
+
+    //@ assert 0 < p <= srclen <= 65535;
+    //@ assert src[p] == 0;
+    //@ assert \forall integer i; 1 <= i < p ==> src[i] != 0;
+    return p-1;
+}
+
+void cobs_decode_incremental_initialize(struct cobs_decode_state *state) {
+    state->p = 0;
+    state->c = 0;
+}
+
+int cobs_decode_incremental(struct cobs_decode_state *state, char *dst, size_t dstlen, char src) {
+    if (state->p == 0) {
+        if (src == 0)
+            goto empty_errout; /* invalid framing. An empty frame would be [...] 00 01 00, not [...] 00 00 */
+        state->c = (unsigned char)src;
+        state->p++;
+        return 0;
+    }
+
+    if (!src) {
+        if (state->c != 1)
+            goto errout; /* Invalid framing. The skip counter does not hit the end of the frame. */
+        int rv = state->p-1;
+        cobs_decode_incremental_initialize(state);
+        return rv;
+    }
+
+    char val;
+    state->c--;
+
+    if (state->c == 0) {
+        state->c = (unsigned char)src;
+        val = 0;
+    } else {
+        val = src;
+    }
+
+    size_t pos = state->p-1;
+    if (pos >= dstlen)
+        return -2; /* output buffer too small */
+    dst[pos] = val;
+    state->p++;
+    return 0;
+
+errout:
+    cobs_decode_incremental_initialize(state);
+    return -1;
+
+empty_errout:
+    cobs_decode_incremental_initialize(state);
+    return -3;
+}
+
+#ifdef VALIDATION
+/*@ 
+  @ requires 0 <= d < 256;
+  @ assigns \nothing;
+  @*/
+size_t test(char foo, unsigned int d) {
+    unsigned int c = (unsigned char)foo;
+    if (c != 0) {
+        //@ assert c < 256;
+        //@ assert c >= 0;
+        //@ assert c != 0;
+        //@ assert c > 0;
+    }
+    if (d != 0) {
+        //@ assert d >= 0;
+        //@ assert d != 0;
+        //@ assert d > 0;
+    }
+    return c + d;
+}
+
+#include <__fc_builtin.h>
+
+void main(void) {
+    char inbuf[254];
+    char cobsbuf[256];
+    char outbuf[256];
+
+    size_t range = Frama_C_interval(0, sizeof(inbuf));
+    Frama_C_make_unknown((char *)inbuf, range);
+
+    cobs_encode(cobsbuf, sizeof(cobsbuf), inbuf, sizeof(inbuf));
+    cobs_decode(outbuf, sizeof(outbuf), cobsbuf, sizeof(cobsbuf));
+    
+    //@ assert \forall integer i; 0 <= i < sizeof(inbuf) ==> outbuf[i] == inbuf[i];
+}
+#endif//VALIDATION
+
diff --git a/hardware/fw/cobs.h b/hardware/fw/cobs.h
new file mode 100644
index 0000000..8c84ca4
--- /dev/null
+++ b/hardware/fw/cobs.h
@@ -0,0 +1,23 @@
+#ifndef __COBS_H__
+#define __COBS_H__
+
+#include <stdint.h>
+#include <unistd.h>
+#include <string.h>
+
+
+struct cobs_decode_state {
+    size_t p;
+    size_t c;
+};
+
+
+ssize_t cobs_encode(char *dst, size_t dstlen, char *src, size_t srclen);
+ssize_t cobs_decode(char *dst, size_t dstlen, char *src, size_t srclen);
+
+int cobs_encode_usart(int (*output)(char), char *src, size_t srclen);
+
+void cobs_decode_incremental_initialize(struct cobs_decode_state *state);
+int cobs_decode_incremental(struct cobs_decode_state *state, char *dst, size_t dstlen, char src);
+
+#endif//__COBS_H__
diff --git a/hardware/fw/crctest.py b/hardware/fw/crctest.py
new file mode 100644
index 0000000..5c97be9
--- /dev/null
+++ b/hardware/fw/crctest.py
@@ -0,0 +1,79 @@
+custom_crc_table = {}
+
+def generate_crc32_table(_poly):
+
+    global custom_crc_table
+
+    for i in range(256):
+        c = i << 24
+
+        for j in range(8):
+            c = (c << 1) ^ _poly if (c & 0x80000000) else c << 1
+
+        custom_crc_table[i] = c & 0xffffffff
+
+
+def crc32_stm(bytes_arr):
+
+    length = len(bytes_arr)
+    crc = 0xffffffff
+
+    k = 0
+    while length >= 4:
+
+        v = ((bytes_arr[k] << 24) & 0xFF000000) | ((bytes_arr[k+1] << 16) & 0xFF0000) | \
+        ((bytes_arr[k+2] << 8) & 0xFF00) | (bytes_arr[k+3] & 0xFF)
+
+        crc = ((crc << 8) & 0xffffffff) ^ custom_crc_table[0xFF & ((crc >> 24) ^ v)]
+        crc = ((crc << 8) & 0xffffffff) ^ custom_crc_table[0xFF & ((crc >> 24) ^ (v >> 8))]
+        crc = ((crc << 8) & 0xffffffff) ^ custom_crc_table[0xFF & ((crc >> 24) ^ (v >> 16))]
+        crc = ((crc << 8) & 0xffffffff) ^ custom_crc_table[0xFF & ((crc >> 24) ^ (v >> 24))]
+
+        k += 4
+        length -= 4
+
+    if length > 0:
+        v = 0
+
+        for i in range(length):
+            v |= (bytes_arr[k+i] << 24-i*8)
+
+        if length == 1:
+            v &= 0xFF000000
+
+        elif length == 2:
+            v &= 0xFFFF0000
+
+        elif length == 3:
+            v &= 0xFFFFFF00
+
+        crc = (( crc << 8 ) & 0xffffffff) ^ custom_crc_table[0xFF & ( (crc >> 24) ^ (v ) )];
+        crc = (( crc << 8 ) & 0xffffffff) ^ custom_crc_table[0xFF & ( (crc >> 24) ^ (v >> 8) )];
+        crc = (( crc << 8 ) & 0xffffffff) ^ custom_crc_table[0xFF & ( (crc >> 24) ^ (v >> 16) )];
+        crc = (( crc << 8 ) & 0xffffffff) ^ custom_crc_table[0xFF & ( (crc >> 24) ^ (v >> 24) )];
+
+    return crc
+
+poly = 0x04C11DB7
+buf = bytes(reversed([1, 2, 3, 4]))
+
+generate_crc32_table(poly)
+print(hex(crc32_stm(bytearray(buf))))
+
+from crccheck import crc
+import struct
+
+def rev_bits_in_word(w):
+    return sum( ((w>>i)&1) << (31-i) for i in range(32) )
+
+import zlib
+def crc32stm(inbytes):    
+    crc32 = crc.Crc32.calc(inbytes)^0xffffffff
+    #crc32 = zlib.crc32(inbytes)^0xffffffff
+    crc32 = rev_bits_in_word(crc32)
+    return crc32
+
+#data = [0x80,0x40,0xc0,0x20]
+data = [0x00, 0, 0, 0x80, 0, 0, 0, 0x80]
+print(hex(crc32stm(bytes(data))))
+print(hex(zlib.crc32(bytes([0, 0, 0, 1]))^0xffffffff))
diff --git a/hardware/fw/global.h b/hardware/fw/global.h
new file mode 100644
index 0000000..28ac6cd
--- /dev/null
+++ b/hardware/fw/global.h
@@ -0,0 +1,62 @@
+/* Megumin LED display firmware
+ * Copyright (C) 2018 Sebastian Götte <code@jaseg.net>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GLOBAL_H__
+#define __GLOBAL_H__
+
+/* Workaround for sub-par ST libraries */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#include <stm32f0xx.h>
+#include <stm32f0xx_ll_utils.h>
+#include <stm32f0xx_ll_spi.h>
+#pragma GCC diagnostic pop
+
+#include <system_stm32f0xx.h>
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+
+/* Microcontroller part number: STM32F030F4P6 */
+
+/* Things used for module status reporting. */
+#define FIRMWARE_VERSION 1
+#define HARDWARE_VERSION 0
+
+#define TS_CAL1 (*(uint16_t *)0x1FFFF7B8)
+#define VREFINT_CAL (*(uint16_t *)0x1FFFF7BA)
+
+#define ARRAY_LEN(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))
+
+extern volatile unsigned int sys_time;
+extern volatile unsigned int sys_time_seconds;
+
+#define UNUSED(var) ((void)var)
+
+union leds {
+    struct {
+        unsigned int pps, sd_card, usb, ocxo, error, _nc1, _nc2, _nc3;
+    };
+    unsigned int arr[8];
+};
+
+extern volatile union leds leds;
+extern volatile int32_t gps_1pps_period_sysclk;
+
+#endif/*__GLOBAL_H__*/
diff --git a/hardware/fw/grid_scope.ipynb b/hardware/fw/grid_scope.ipynb
new file mode 100644
index 0000000..1e5f942
--- /dev/null
+++ b/hardware/fw/grid_scope.ipynb
@@ -0,0 +1,3699 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import sqlite3\n",
+    "import struct\n",
+    "import datetime\n",
+    "\n",
+    "import matplotlib\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib import patches\n",
+    "import numpy as np\n",
+    "from scipy import signal, optimize\n",
+    "from tqdm.notebook import tnrange, tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib notebook"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db = sqlite3.connect('waveform.sqlite3')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Run 000: 2020-01-30 14:24:25 - 2020-01-30 14:24:33 (  0:00:07.571,      6880sp)\n",
+      "Run 001: 2020-01-30 14:24:56 - 2020-01-30 14:25:25 (  0:00:28.305,      8992sp)\n",
+      "Run 002: 2020-01-30 14:25:33 - 2020-01-30 14:30:37 (  0:05:04.016,    290112sp)\n",
+      "Run 003: 2020-01-30 14:31:31 - 2020-01-30 14:37:59 (  0:06:27.900,    384192sp)\n",
+      "Run 004: 2020-01-30 14:38:30 - 2020-01-30 14:45:27 (  0:06:56.604,    417216sp)\n",
+      "Run 005: 2020-01-30 15:18:50 - 2020-01-30 15:19:01 (  0:00:10.690,     10240sp)\n",
+      "Run 006: 2020-01-30 16:37:15 - 2020-01-30 16:37:17 (  0:00:02.527,      2560sp)\n",
+      "Run 007: 2020-01-30 16:44:23 - 2020-01-30 16:58:48 (  0:14:24.293,    665600sp)\n",
+      "Run 008: 2020-01-30 17:06:35 - 2020-01-30 17:46:16 (  0:39:41.608,   2163168sp)\n",
+      "Run 009: 2020-01-30 17:46:20 - 2020-01-30 18:11:16 (  0:24:55.928,   1492480sp)\n",
+      "Run 010: 2020-01-30 18:11:39 - 2020-01-30 18:22:29 (  0:10:50.025,    642560sp)\n",
+      "Run 011: 2020-01-30 18:22:32 - 2020-01-30 19:33:52 (  1:11:20.495,   4280320sp)\n",
+      "Run 012: 2020-01-31 13:16:53 - 2020-01-31 13:18:12 (  0:01:19.317,     79360sp)\n",
+      "Run 013: 2020-01-31 13:30:54 - 2020-01-31 13:31:35 (  0:00:40.762,     40960sp)\n",
+      "Run 014: 2020-01-31 13:45:37 - 2020-01-31 13:45:42 (  0:00:05.090,      5120sp)\n",
+      "Run 015: 2020-01-31 13:53:56 - 2020-01-31 13:54:01 (  0:00:05.089,      5120sp)\n",
+      "Run 016: 2020-01-31 13:54:21 - 2020-01-31 13:54:26 (  0:00:05.088,      5120sp)\n",
+      "Run 017: 2020-01-31 13:55:41 - 2020-01-31 13:55:46 (  0:00:05.087,      5120sp)\n",
+      "Run 018: 2020-01-31 13:56:13 - 2020-01-31 13:56:19 (  0:00:05.091,      5120sp)\n",
+      "Run 019: 2020-01-31 13:56:27 - 2020-01-31 13:56:30 (  0:00:02.527,      2560sp)\n",
+      "Run 020: 2020-01-31 13:56:40 - 2020-01-31 13:56:48 (  0:00:07.649,      7680sp)\n",
+      "Run 021: 2020-01-31 13:57:10 - 2020-01-31 13:58:34 (  0:01:24.342,     84416sp)\n",
+      "Run 022: 2020-01-31 14:05:08 - 2020-01-31 14:05:24 (  0:00:15.242,     15360sp)\n",
+      "Run 023: 2020-01-31 14:05:33 - 2020-01-31 14:12:50 (  0:07:17.092,    435200sp)\n",
+      "Run 024: 2020-01-31 14:13:21 - 2020-01-31 14:15:39 (  0:02:18.190,    138240sp)\n",
+      "Run 025: 2020-01-31 14:18:16 - 2020-01-31 18:58:25 (  4:40:09.251,  16611840sp)\n"
+     ]
+    }
+   ],
+   "source": [
+    "for run_id, start, end, count in db.execute('SELECT run_id, MIN(rx_ts), MAX(rx_ts), COUNT(*) FROM measurements GROUP BY run_id'):\n",
+    "    foo = lambda x: datetime.datetime.fromtimestamp(x/1000)\n",
+    "    start, end = foo(start), foo(end)\n",
+    "    print(f'Run {run_id:03d}: {start:%Y-%m-%d %H:%M:%S} - {end:%Y-%m-%d %H:%M:%S} ({str(end-start)[:-3]:>13}, {count*32:>9d}sp)')\n",
+    "last_run, n_records = run_id, count\n",
+    "sampling_rate = 1000.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "par = lambda *rs: 1/sum(1/r for r in rs) # resistor parallel calculation\n",
+    "\n",
+    "# FIXME: These are for the first prototype only!\n",
+    "vmeas_source_impedance = 330e3\n",
+    "vmeas_source_scale = 0.5\n",
+    "\n",
+    "vcc = 15.0\n",
+    "vmeas_div_high = 27e3\n",
+    "vmeas_div_low = par(4.7e3, 10e3)\n",
+    "vmeas_div_voltage = vcc * vmeas_div_low / (vmeas_div_high + vmeas_div_low)\n",
+    "vmeas_div_impedance = par(vmeas_div_high, vmeas_div_low)\n",
+    "\n",
+    "#vmeas_overall_factor = vmeas_div_impedance / (vmeas_source_impedance + vmeas_div_impedance)\n",
+    "v0 = 1.5746\n",
+    "v100 = 2.004\n",
+    "vn100 = 1.1452\n",
+    "\n",
+    "adc_vcc = 3.3 # V\n",
+    "adc_fullscale = 4095\n",
+    "\n",
+    "adc_val_to_voltage_factor = 1/adc_fullscale * adc_vcc\n",
+    "\n",
+    "adc_count_to_vmeas = lambda x: (x*adc_val_to_voltage_factor - v0) / (v100-v0) * 100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "afc732c0ada8419e89a7ff2551212c00",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(IntProgress(value=0, max=519120), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "limit = n_records\n",
+    "record_size = 32\n",
+    "skip_dropped_sections = False\n",
+    "\n",
+    "data = np.zeros(limit*record_size)\n",
+    "data[:] = np.nan\n",
+    "\n",
+    "last_seq = None\n",
+    "write_index = 0\n",
+    "for i, (seq, chunk) in tqdm(enumerate(db.execute(\n",
+    "        'SELECT seq, data FROM measurements WHERE run_id = ? ORDER BY rx_ts LIMIT ? OFFSET ?',\n",
+    "        (last_run, limit, n_records-limit))), total=n_records):\n",
+    "    \n",
+    "    if last_seq is None or seq == (last_seq + 1)%0xffff:\n",
+    "        last_seq = seq\n",
+    "        idx = write_index if skip_dropped_sections else i\n",
+    "        data[idx*record_size:(idx+1)*record_size] = np.frombuffer(chunk, dtype='<H')\n",
+    "        write_index += 1\n",
+    "        \n",
+    "    elif seq > last_seq:\n",
+    "        last_seq = seq\n",
+    "        # nans = np.empty((record_size,))\n",
+    "        # nans[:] = np.nan\n",
+    "        # data = np.append(data, nans) FIXME\n",
+    "        \n",
+    "data = (data * adc_val_to_voltage_factor - v0) / (v100-v0) * 100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "227.138252895397"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data_not_nan = data[~np.isnan(data)]\n",
+    "np.sqrt(np.mean(np.square(data_not_nan)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"900\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, (top, bottom) = plt.subplots(2, figsize=(9,6))\n",
+    "fig.tight_layout(pad=3, h_pad=0.1)\n",
+    "\n",
+    "range_start, range_len = -300, 60 # [s]\n",
+    "\n",
+    "data_slice = data[ int(range_start * sampling_rate) : int((range_start + range_len) * sampling_rate) ]\n",
+    "\n",
+    "top.grid()\n",
+    "top.plot(np.linspace(0, range_len, int(range_len*sampling_rate)), data_slice, lw=1.0)\n",
+    "top.set_xlim([range_len/2-0.25, range_len/2+0.25])\n",
+    "mean = np.mean(data_not_nan)\n",
+    "rms = np.sqrt(np.mean(np.square(data_not_nan - mean)))\n",
+    "peak = np.max(np.abs(data_not_nan - mean))\n",
+    "top.axhline(mean, color='red')\n",
+    "bbox = {'facecolor': 'black', 'alpha': 0.8, 'pad': 2}\n",
+    "top.text(0, mean, f'mean: {mean:.3f}', color='white', bbox=bbox)\n",
+    "top.text(0.98, 0.2, f'V_RMS: {rms:.3f}', transform=top.transAxes, color='white', bbox=bbox, ha='right')\n",
+    "top.text(0.98, 0.1, f'V_Pk: {peak:.3f}', transform=top.transAxes, color='white', bbox=bbox, ha='right')\n",
+    "\n",
+    "bottom.grid()\n",
+    "bottom.specgram(data_slice, Fs=sampling_rate)\n",
+    "top.set_ylabel('U [V]')\n",
+    "bottom.set_ylabel('F [Hz]')\n",
+    "bottom.set_xlabel('t [s]')\n",
+    "None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fs = sampling_rate # Hz\n",
+    "ff = 50 # Hz\n",
+    "\n",
+    "analysis_periods = 10\n",
+    "window_len = fs * analysis_periods/ff\n",
+    "nfft_factor = 4\n",
+    "sigma = window_len/8 # samples\n",
+    "\n",
+    "f, t, Zxx = signal.stft(data,\n",
+    "            fs = fs,\n",
+    "            window=('gaussian', sigma),\n",
+    "            nperseg = window_len,\n",
+    "            nfft = window_len * nfft_factor)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"900\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(9, 3))\n",
+    "fig.tight_layout(pad=2, h_pad=0.1)\n",
+    "\n",
+    "ax.pcolormesh(t[-200:-100], f[:250], np.abs(Zxx[:250,-200:-100]))\n",
+    "ax.set_title(f\"Run {last_run}\", pad=-20, color='white')\n",
+    "ax.grid()\n",
+    "ax.set_ylabel('f [Hz]')\n",
+    "ax.set_ylim([30, 75]) # Hz\n",
+    "ax.set_xlabel('simulation time t [s]')\n",
+    "None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "36ffcac30c8b4b378d3c422d3ef0698b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(IntProgress(value=0, max=166118), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "f_t = t\n",
+    "\n",
+    "n_f, n_t = Zxx.shape\n",
+    "# start, stop = 180, 220\n",
+    "# start, stop = 90, 110\n",
+    "# start, stop = 15, 35\n",
+    "# bounds_f = slice(start // 4 * nfft_factor, stop // 4 * nfft_factor)\n",
+    "f_min, f_max = 30, 70 # Hz\n",
+    "bounds_f = slice(np.argmax(f > f_min), np.argmin(f < f_max))\n",
+    "\n",
+    "\n",
+    "f_mean = np.zeros(Zxx.shape[1])\n",
+    "for le_t in tnrange(1, Zxx.shape[1] - 1):\n",
+    "    frame_f = f[bounds_f]\n",
+    "    frame_step = frame_f[1] - frame_f[0]\n",
+    "    time_step = f_t[1] - f_t[0]\n",
+    "    #if t == 10:\n",
+    "    #    axs[-1].plot(frame_f, frame_Z)\n",
+    "    frame_Z = np.abs(Zxx[bounds_f, le_t])\n",
+    "    # frame_f = f[180:220]\n",
+    "    # frame_Z = np.abs(Zxx[180:220, 40])\n",
+    "    # frame_f = f[15:35]\n",
+    "    # frame_Z = np.abs(Zxx[15:35, 40])\n",
+    "    # plt.plot(frame_f, frame_Z)\n",
+    "\n",
+    "    # peak_f = frame_f[np.argmax(frame)]\n",
+    "    # plt.axvline(peak_f, color='red')\n",
+    "\n",
+    "#         def gauss(x, *p):\n",
+    "#             A, mu, sigma, o = p\n",
+    "#             return A*np.exp(-(x-mu)**2/(2.*sigma**2)) + o\n",
+    "\n",
+    "    def gauss(x, *p):\n",
+    "        A, mu, sigma = p\n",
+    "        return A*np.exp(-(x-mu)**2/(2.*sigma**2))\n",
+    "\n",
+    "    f_start = frame_f[np.argmax(frame_Z)]\n",
+    "    A_start = np.max(frame_Z)\n",
+    "    p0 = [A_start, f_start, 1.]\n",
+    "    try:\n",
+    "        coeff, var = optimize.curve_fit(gauss, frame_f, frame_Z, p0=p0)\n",
+    "        # plt.plot(frame_f, gauss(frame_f, *coeff))\n",
+    "        #print(coeff)\n",
+    "        A, mu, sigma, *_ = coeff\n",
+    "        f_mean[le_t] = mu\n",
+    "    except Exception:\n",
+    "        f_mean[le_t] = np.nan"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"900\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(9, 5), sharex=True)\n",
+    "fig.tight_layout(pad=2.2, h_pad=0, w_pad=1)\n",
+    "\n",
+    "label = f'Run {last_run}'\n",
+    "ax.plot(f_t[1:-1], f_mean[1:-1])\n",
+    "\n",
+    "#     b, a = signal.butter(3,\n",
+    "#                          1/5, # Hz\n",
+    "#                          btype='lowpass',\n",
+    "#                          fs=1/time_step)\n",
+    "#     filtered = signal.lfilter(b, a, f_mean[1:-1], axis=0)\n",
+    "#     ax.plot(f_t[1:-1], filtered)\n",
+    "\n",
+    "ax.set_title(label, pad=-20)\n",
+    "ax.set_ylabel('f [Hz]')\n",
+    "ax.grid()\n",
+    "if not label in ['off_frequency', 'sweep_phase_steps']:\n",
+    "    ax.set_ylim([49.90, 50.10])\n",
+    "    var = np.var(f_mean[~np.isnan(f_mean)][1:-1])\n",
+    "    ax.text(0.5, 0.08, f'σ²={var * 1e3:.3g} mHz²', transform=ax.transAxes, ha='center', color='white', bbox=bbox)\n",
+    "    ax.text(0.5, 0.15, f'σ={np.sqrt(var) * 1e3:.3g} mHz', transform=ax.transAxes, ha='center', color='white', bbox=bbox)\n",
+    "\n",
+    "#         ax.text(0.5, 0.2, f'filt. σ²={np.var(filtered) * 1e3:.3g} mHz', transform=ax.transAxes, ha='center')\n",
+    "else:\n",
+    "    f_min, f_max = min(f_mean[1:-1]), max(f_mean[1:-1])\n",
+    "    delta = f_max - f_min\n",
+    "    ax.set_ylim(f_min - delta * 0.1, f_max + delta * 0.3)\n",
+    "\n",
+    "for i in np.where(np.isnan(f_mean))[0]:\n",
+    "    ax.axvspan(f_t[i], f_t[i+1], color='lightblue')\n",
+    "\n",
+    "ax.set_xlabel('recording time t [s]')\n",
+    "None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"900\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "f_copy = np.copy(f_mean[1:-1])\n",
+    "f_copy[np.isnan(f_copy)] = np.mean(f_copy[~np.isnan(f_copy)])\n",
+    "b, a = signal.cheby2(7, 86, 100, 'low', output='ba', fs=1000)\n",
+    "filtered = signal.lfilter(b, a, f_copy)\n",
+    "\n",
+    "b2, a2 = signal.cheby2(3, 30, 1, 'high', output='ba', fs=1000)\n",
+    "filtered2 = signal.lfilter(b2, a2, filtered)\n",
+    "\n",
+    "fig, (ax2, ax1) = plt.subplots(2, figsize=(9,7))\n",
+    "ax1.plot(f_t[1:-1], f_copy, color='lightgray')\n",
+    "ax1.set_ylim([49.90, 50.10])\n",
+    "ax1.grid()\n",
+    "formatter = matplotlib.ticker.FuncFormatter(lambda s, x: str(datetime.timedelta(seconds=s)))\n",
+    "ax1.xaxis.set_major_formatter(formatter)\n",
+    "zoom_offx = 7000 # s\n",
+    "zoom_len = 300 # s\n",
+    "ax1.set_xlim([zoom_offx, zoom_offx + zoom_len])\n",
+    "\n",
+    "ax1.plot(f_t[1:-1], filtered, color='orange')\n",
+    "ax1r = ax1.twinx()\n",
+    "ax1r.plot(f_t[1:-1], filtered2, color='red')\n",
+    "ax1r.set_ylim([-0.015, 0.015])\n",
+    "ax1.set_title(f'Zoomed trace ({datetime.timedelta(seconds=zoom_len)})', pad=-20)\n",
+    "\n",
+    "\n",
+    "ax2.set_title(f'Run {last_run}')\n",
+    "ax2.plot(f_t[1:-1], f_copy, color='orange')\n",
+    "\n",
+    "ax2r = ax2.twinx()\n",
+    "ax2r.set_ylim([-0.1, 0.1])\n",
+    "ax2r.plot(f_t[1:-1], filtered2, color='red')\n",
+    "#ax2.plot(f_t[1:-1], filtered, color='orange', zorder=1)\n",
+    "ax2.set_ylim([49.90, 50.10])\n",
+    "ax2.set_xlim([0, f_t[-2]])\n",
+    "ax2.grid()\n",
+    "formatter = matplotlib.ticker.FuncFormatter(lambda s, x: str(datetime.timedelta(seconds=s)))\n",
+    "ax2.xaxis.set_major_formatter(formatter)\n",
+    "\n",
+    "ax2.legend(handles=[\n",
+    "    patches.Patch(color='lightgray', label='Raw frequency'),\n",
+    "    patches.Patch(color='orange', label='low-pass filtered'),\n",
+    "    patches.Patch(color='red', label='band-pass filtered')])\n",
+    "\n",
+    "#ax2r.spines['right'].set_color('red')\n",
+    "ax2r.yaxis.label.set_color('red')\n",
+    "#ax2r.tick_params(axis='y', colors='red')\n",
+    "\n",
+    "#ax1r.spines['right'].set_color('red')\n",
+    "ax1r.yaxis.label.set_color('red')\n",
+    "#ax1r.tick_params(axis='y', colors='red')\n",
+    "\n",
+    "ax1.set_ylabel('f [Hz]')\n",
+    "ax1r.set_ylabel('band-pass Δf [Hz]')\n",
+    "ax2.set_ylabel('f [Hz]')\n",
+    "ax2r.set_ylabel('band-pass Δf [Hz]')\n",
+    "\n",
+    "# Cut out first 10min of filtered data to give filters time to settle\n",
+    "rms_slice = filtered2[np.where(f_t[1:] > 10*60)[0][0]:]\n",
+    "rms = np.sqrt(np.mean(np.square(rms_slice)))\n",
+    "ax1.text(0.5, 0.1, f'RMS (band-pass): {rms*1e3:.3f}mHz', transform=ax1.transAxes, color='white', bbox=bbox, ha='center')\n",
+    "None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chunk_size = 256\n",
+    "\n",
+    "with open('filtered_freq.bin', 'wb') as f:\n",
+    "    for chunk in range(0, len(rms_slice), chunk_size):\n",
+    "        out_data = rms_slice[chunk:chunk+chunk_size]\n",
+    "        f.write(struct.pack(f'{len(out_data)}f',  *out_data))\n",
+    "        \n",
+    "with open('raw_freq.bin', 'wb') as f:\n",
+    "    for chunk in range(0, len(f_copy), chunk_size):\n",
+    "        out_data = f_copy[chunk:chunk+chunk_size]\n",
+    "        f.write(struct.pack(f'{len(out_data)}f',  *out_data))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(160118,)"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def modulate(sequences, data)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/hardware/fw/main.c b/hardware/fw/main.c
new file mode 100644
index 0000000..34c838b
--- /dev/null
+++ b/hardware/fw/main.c
@@ -0,0 +1,241 @@
+/* Megumin LED display firmware
+ * Copyright (C) 2018 Sebastian Götte <code@jaseg.net>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "global.h"
+#include "adc.h"
+#include "serial.h"
+
+
+volatile unsigned int sys_time_seconds = 0;
+volatile union leds leds;
+volatile int32_t gps_1pps_period_sysclk = -1;
+
+int main(void) {
+    /* Get GPIOA and SPI1 up to flash status LEDs */
+    RCC->AHBENR  |= RCC_AHBENR_GPIOAEN;
+    RCC->APB2ENR |= RCC_APB2ENR_SPI1EN;
+
+    GPIOA->MODER |=
+          (3<<GPIO_MODER_MODER2_Pos)  /* PA2  - LINE_MEAS */
+        | (1<<GPIO_MODER_MODER3_Pos)  /* PA3  - LED_STB */
+        | (1<<GPIO_MODER_MODER4_Pos)  /* PA4  - SD_CS */
+        | (2<<GPIO_MODER_MODER5_Pos)  /* PA5  - SCK */
+        | (2<<GPIO_MODER_MODER6_Pos)  /* PA6  - MISO */
+        | (2<<GPIO_MODER_MODER7_Pos)  /* PA7  - MOSI */
+        | (2<<GPIO_MODER_MODER9_Pos)  /* PA9  - HOST_RX */
+        | (2<<GPIO_MODER_MODER10_Pos);/* PA10 - HOST_TX */
+
+    /* Set shift register IO GPIO output speed */
+    GPIOA->OSPEEDR |=
+          (2<<GPIO_OSPEEDR_OSPEEDR3_Pos)   /* LED_STB */
+        | (2<<GPIO_OSPEEDR_OSPEEDR4_Pos)   /* SD_CS */
+        | (2<<GPIO_OSPEEDR_OSPEEDR5_Pos)   /* SCK */
+        | (2<<GPIO_OSPEEDR_OSPEEDR7_Pos)   /* MOSI */
+        | (2<<GPIO_OSPEEDR_OSPEEDR9_Pos);  /* HOST_RX */
+
+    GPIOA->AFR[0] = (0<<GPIO_AFRL_AFRL5_Pos) | (0<<GPIO_AFRL_AFRL6_Pos) | (0<<GPIO_AFRL_AFRL7_Pos);
+    GPIOA->AFR[1] = (1<<8) | (1<<4);
+
+    SPI1->CR1 =
+          SPI_CR1_SSM
+        | SPI_CR1_SSI
+        | SPI_CR1_CPOL
+        | SPI_CR1_CPHA
+        | (4<<SPI_CR1_BR_Pos) /* /32 ~1.5MHz */
+        | SPI_CR1_MSTR;
+    SPI1->CR2 = (7<<SPI_CR2_DS_Pos);
+    SPI1->CR1 |= SPI_CR1_SPE;
+    *((volatile uint8_t*)&(SPI1->DR)) = 0xff;
+
+    /* Wait for OCXO to settle */
+    for (int i=0; i<1000000; i++)
+        ;
+
+    /* Switch clock to PLL based on OCXO input */
+    RCC->CR |= RCC_CR_HSEBYP;
+    RCC->CR |= RCC_CR_HSEON;
+    RCC->CFGR &= ~RCC_CFGR_PLLMUL_Msk & ~RCC_CFGR_SW_Msk & ~RCC_CFGR_PPRE_Msk & ~RCC_CFGR_HPRE_Msk;
+    /* PLL config: 19.44MHz /2 x5 -> 48.6MHz */
+    RCC->CFGR |= ((5-2)<<RCC_CFGR_PLLMUL_Pos) | RCC_CFGR_PLLSRC_HSE_PREDIV;
+    RCC->CFGR2 = ((2-1)<<RCC_CFGR2_PREDIV_Pos);
+    RCC->CR |= RCC_CR_PLLON;
+    while (!(RCC->CR&RCC_CR_PLLRDY));
+    RCC->CFGR |= (2<<RCC_CFGR_SW_Pos);
+    SystemCoreClockUpdate();
+
+    /* Start systick */
+    SysTick_Config(SystemCoreClock/10); /* 100ms interval */
+    NVIC_EnableIRQ(SysTick_IRQn);
+    NVIC_SetPriority(SysTick_IRQn, 3<<5);
+
+    /* Turn on rest of periphery */
+    RCC->AHBENR  |= RCC_AHBENR_DMAEN | RCC_AHBENR_GPIOBEN | RCC_AHBENR_FLITFEN | RCC_AHBENR_CRCEN;
+    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN | RCC_APB2ENR_ADCEN  | RCC_APB2ENR_DBGMCUEN |\
+                    RCC_APB2ENR_TIM1EN | RCC_APB2ENR_TIM16EN | RCC_APB2ENR_USART1EN;
+    RCC->APB1ENR |= RCC_APB1ENR_TIM3EN | RCC_APB1ENR_TIM14EN;
+
+    GPIOB->MODER |=
+          (2<<GPIO_MODER_MODER1_Pos); /* PB0  - GPS 1pps input */
+    GPIOB->AFR[0] = (0<<GPIO_AFRL_AFRL1_Pos);
+    GPIOB->PUPDR = 2<<GPIO_PUPDR_PUPDR1_Pos;
+
+    /* Configure TIM16 for LED update via SPI */
+    TIM16->CR2 = 0;
+    TIM16->DIER = TIM_DIER_UIE | TIM_DIER_CC1IE;
+    TIM16->CCMR1 = 0;
+    TIM16->CCR1 = 32;
+    TIM16->PSC = 48-1; /* 1us */
+    TIM16->ARR = 1000-1; /* 1ms */
+    TIM16->CR1 = TIM_CR1_CEN;
+    NVIC_EnableIRQ(TIM16_IRQn);
+
+    /* Configure TIM14 for GPS 1pps input capture */
+    TIM14->CCMR1 = (1<<TIM_CCMR1_CC1S_Pos) | (3<<TIM_CCMR1_IC1F_Pos);
+    TIM14->CCER = TIM_CCER_CC1E;
+    TIM14->PSC = 1;
+    TIM14->ARR = 0xffff;
+    TIM14->DIER = TIM_DIER_CC1IE | TIM_DIER_UIE;
+    TIM14->EGR = TIM_EGR_UG;
+    TIM14->CR1  |= TIM_CR1_CEN;
+    NVIC_EnableIRQ(TIM14_IRQn);
+
+    adc_init(1000000);
+	adc_timer_init(243, 200); /* 19.44 MHz / 243 -> 200 kHz; /200 -> 1 kHz */
+
+    usart_dma_init();
+
+    while (42) {
+        /* Do nothing and let the interrupts do all the work. */
+    }
+}
+
+void tim14_sr_cc1of(void) {} /* gdb hook */
+
+void TIM14_IRQHandler(void) {
+    static uint32_t gps_1pps_period = 0;
+    static uint32_t update_inc = 0;
+    static bool in_sync = false;
+
+    uint32_t sr = TIM14->SR;
+    if (sr & TIM_SR_CC1OF) {
+        TIM14->SR &= ~(TIM_SR_CC1IF | TIM_SR_CC1OF);
+        tim14_sr_cc1of();
+
+    }
+    if (sr & TIM_SR_UIF) {
+        TIM14->SR &= ~TIM_SR_UIF;
+        if (in_sync) {
+            gps_1pps_period += update_inc;
+            if (gps_1pps_period > 30000000) { /* Signal out of range */
+                in_sync = false;
+                gps_1pps_period_sysclk = -1;
+                gps_1pps_period = (uint32_t)-1;
+            }
+        }
+        update_inc = 0x10000;
+    }
+
+    if (sr & TIM_SR_CC1IF) { /* CC1 event (GPS 1pps input) */
+        /* Don't reset update event: If update event arrives while CC1 event is being processed leave UIF set to process
+         * update event immediately after return from ISR. */
+        uint16_t ccr = TIM14->CCR1;
+        if (in_sync) {
+            uint32_t new_period = gps_1pps_period + ccr;
+            if (new_period < 20000000 || new_period > 30000000) { /* Signal out of range */
+                in_sync = false;
+                gps_1pps_period_sysclk = -1;
+                gps_1pps_period = (uint32_t)-1;
+            } else {
+                if ((sr & TIM_SR_UIF) /* we processed an update event in this ISR */
+                    && (ccr > 0xc000) /* and the capture happened late in the cycle */
+                        ) {
+                    gps_1pps_period_sysclk = new_period - 0x10000;
+                    update_inc = 0x10000;
+                    gps_1pps_period = 0x10000 - ccr;
+                } else {
+                    gps_1pps_period_sysclk = new_period;
+                    update_inc = 0x10000 - ccr; /* remaining cycles in this period */
+                    gps_1pps_period = 0;
+                }
+                leds.pps = 200; /* ms */
+            }
+        } else {
+            gps_1pps_period = 0;
+            update_inc = 0x10000 - ccr; /* remaining cycles in this period */
+            in_sync = true;
+        }
+
+    }
+}
+
+void TIM16_IRQHandler(void) {
+    static int leds_update_counter = 0;
+    if (TIM16->SR & TIM_SR_UIF) {
+        TIM16->SR &= ~TIM_SR_UIF;
+
+        uint8_t bits = 0, mask = 1;
+        for (int i=0; i<8; i++) {
+            if (leds.arr[i]) {
+                leds.arr[i]--;
+                bits |= mask;
+            }
+            mask <<= 1;
+        }
+
+        if (leds_update_counter++ == 10) {
+            leds_update_counter = 0;
+
+            /* Workaround for SPI hardware bug: Even if configured to 8-bit mode, the SPI will do a 16-bit transfer if the
+             * data register is accessed through a 16-bit write. Unfortunately, the STMCube register defs define DR as an
+             * uint16_t, so we have to do some magic here to force an 8-bit write. */
+            *((volatile uint8_t*)&(SPI1->DR)) = bits;
+            GPIOA->BRR = 1<<3;
+        }
+    } else {
+        TIM16->SR &= ~TIM_SR_CC1IF;
+        GPIOA->BSRR = 1<<3;
+    }
+}
+
+void NMI_Handler(void) {
+    asm volatile ("bkpt");
+}
+
+void HardFault_Handler(void) __attribute__((naked));
+void HardFault_Handler() {
+    asm volatile ("bkpt");
+}
+
+void SVC_Handler(void) {
+    asm volatile ("bkpt");
+}
+
+
+void PendSV_Handler(void) {
+    asm volatile ("bkpt");
+}
+
+void SysTick_Handler(void) {
+    static int n = 0;
+    if (n++ == 10) {
+        n = 0;
+        sys_time_seconds++;
+        if (gps_1pps_period_sysclk < 0)
+            leds.pps = 200; /* ms */
+    }
+}
+
diff --git a/hardware/fw/main.c.bak b/hardware/fw/main.c.bak
new file mode 100644
index 0000000..07d065d
--- /dev/null
+++ b/hardware/fw/main.c.bak
@@ -0,0 +1,162 @@
+/* Megumin LED display firmware
+ * Copyright (C) 2018 Sebastian Götte <code@jaseg.net>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "global.h"
+
+#include "adc.h"
+
+volatile unsigned int sys_time = 0;
+volatile unsigned int sys_time_seconds = 0;
+
+void TIM1_BRK_UP_TRG_COM_Handler() {
+    TIM1->SR &= ~TIM_SR_UIF_Msk;
+}
+
+int main(void) {
+    RCC->CR |= RCC_CR_HSEON;
+    while (!(RCC->CR&RCC_CR_HSERDY));
+    RCC->CFGR &= ~RCC_CFGR_PLLMUL_Msk & ~RCC_CFGR_SW_Msk & ~RCC_CFGR_PPRE_Msk & ~RCC_CFGR_HPRE_Msk;
+    RCC->CFGR |= ((6-2)<<RCC_CFGR_PLLMUL_Pos) | RCC_CFGR_PLLSRC_HSE_PREDIV; /* PLL x6 -> 48.0MHz */
+    RCC->CR |= RCC_CR_PLLON;
+    while (!(RCC->CR&RCC_CR_PLLRDY));
+    RCC->CFGR |= (2<<RCC_CFGR_SW_Pos);
+    SystemCoreClockUpdate();
+    SysTick_Config(SystemCoreClock/1000); /* 1ms interval */
+
+    /* Turn on lots of neat things */
+    RCC->AHBENR  |= RCC_AHBENR_DMAEN | RCC_AHBENR_GPIOAEN | RCC_AHBENR_FLITFEN;
+    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN | RCC_APB2ENR_ADCEN| RCC_APB2ENR_DBGMCUEN | RCC_APB2ENR_TIM1EN | RCC_APB2ENR_TIM1EN;;
+    RCC->APB1ENR |= RCC_APB1ENR_TIM3EN;
+
+    GPIOA->MODER |=
+          (3<<GPIO_MODER_MODER0_Pos)  /* PA0  - Vmeas_A to ADC */
+        | (3<<GPIO_MODER_MODER1_Pos)  /* PA1  - Vmeas_B to ADC */
+        | (1<<GPIO_MODER_MODER2_Pos)  /* PA2  - LOAD */
+        | (1<<GPIO_MODER_MODER3_Pos)  /* PA3  - CH0 */
+        | (1<<GPIO_MODER_MODER4_Pos)  /* PA4  - CH3 */
+        | (0<<GPIO_MODER_MODER5_Pos)  /* PA5  - TP1 */
+        | (1<<GPIO_MODER_MODER6_Pos)  /* PA6  - CH2 */
+        | (1<<GPIO_MODER_MODER7_Pos)  /* PA7  - CH1 */
+        | (0<<GPIO_MODER_MODER9_Pos)  /* PA9  - TP2 */
+        | (0<<GPIO_MODER_MODER10_Pos);/* PA10 - TP3 */
+
+    /* Set shift register IO GPIO output speed */
+    GPIOA->OSPEEDR |=
+          (2<<GPIO_OSPEEDR_OSPEEDR2_Pos)   /* LOAD */
+        | (2<<GPIO_OSPEEDR_OSPEEDR3_Pos)   /* CH0 */
+        | (2<<GPIO_OSPEEDR_OSPEEDR4_Pos)   /* CH3   */
+        | (2<<GPIO_OSPEEDR_OSPEEDR6_Pos)   /* CH2 */
+        | (2<<GPIO_OSPEEDR_OSPEEDR7_Pos);  /* CH1 */
+
+    /* Setup CC1 and CC2. CC2 generates the LED drivers' STROBE, CC1 triggers the IRQ handler */
+    TIM1->BDTR  = TIM_BDTR_MOE;
+    TIM1->CCMR2 = (6<<TIM_CCMR2_OC4M_Pos); /* PWM Mode 1 */
+    TIM1->CCER  = TIM_CCER_CC4E;
+    TIM1->CCR4  = 1;
+    TIM1->DIER  = TIM_DIER_UIE;
+
+    TIM1->PSC   = SystemCoreClock/500000 - 1; /* 0.5us/tick */
+    TIM1->ARR   = 25-1;
+    /* Preload all values */
+    TIM1->EGR  |= TIM_EGR_UG;
+    TIM1->CR1   = TIM_CR1_ARPE;
+    /* And... go! */
+    TIM1->CR1  |= TIM_CR1_CEN;
+
+    void set_outputs(uint8_t val) {
+        int a=!!(val&1), b=!!(val&2), c=!!(val&4), d=!!(val&8);
+        GPIOA->ODR &= ~(!a<<3 | !b<<7 | c<<6 | d<<4);
+        GPIOA->ODR |= a<<3 | b<<7 | !c<<6 | !d<<4;
+    }
+    set_outputs(0);
+
+    adc_init();
+
+    uint8_t out_state = 0x01;
+#define DEBOUNCE 100
+    int debounce_ctr = 0;
+    int val_last = 0;
+    int ctr = 0;
+#define RESET 1000
+    int reset_ctr = 0;
+    while (42) {
+#define FOO 500000
+        if (reset_ctr)
+            reset_ctr--;
+        else
+            set_outputs(0);
+
+        if (debounce_ctr) {
+            debounce_ctr--;
+        } else {
+            int val = !!(GPIOA->IDR & 1);
+            debounce_ctr = DEBOUNCE;
+
+            if (val != val_last) {
+                if (val)
+                    set_outputs(out_state & 0xf);
+                else
+                    set_outputs(out_state >> 4);
+                reset_ctr = RESET;
+                val_last = val;
+                ctr++;
+
+                if (ctr == 100) {
+                    ctr = 0;
+                    out_state = out_state<<1 | out_state>>7;
+                }
+            }
+        }
+        /*
+        for (int i=0; i<FOO; i++) ;
+        set_outputs(0x1);
+        for (int i=0; i<FOO; i++) ;
+        set_outputs(0x2);
+        for (int i=0; i<FOO; i++) ;
+        set_outputs(0x4);
+        for (int i=0; i<FOO; i++) ;
+        set_outputs(0x8);
+        */
+        //for (int i=0; i<8*FOO; i++) ;
+        //GPIOA->ODR ^= 4;
+    }
+}
+
+void NMI_Handler(void) {
+}
+
+void HardFault_Handler(void) __attribute__((naked));
+void HardFault_Handler() {
+    asm volatile ("bkpt");
+}
+
+void SVC_Handler(void) {
+}
+
+
+void PendSV_Handler(void) {
+}
+
+void SysTick_Handler(void) {
+    static int n = 0;
+    sys_time++;
+    if (n++ == 1000) {
+        n = 0;
+        sys_time_seconds++;
+    }
+}
+
diff --git a/hardware/fw/openocd.cfg b/hardware/fw/openocd.cfg
new file mode 100644
index 0000000..ce164b7
--- /dev/null
+++ b/hardware/fw/openocd.cfg
@@ -0,0 +1,17 @@
+telnet_port 4445
+gdb_port 3334
+tcl_port 6667
+
+source [find interface/stlink-v2.cfg]
+#interface jlink
+#interface stlink-v2
+#adapter_khz 10000
+#transport select swd
+
+#source /usr/share/openocd/scripts/target/stm32f0x.cfg
+source [find target/stm32f0x_stlink.cfg]
+
+init
+arm semihosting enable
+
+#flash bank sysflash.alias stm32f0x 0x00000000 0 0 0 $_TARGETNAME
diff --git a/hardware/fw/packet_interface.c b/hardware/fw/packet_interface.c
new file mode 100644
index 0000000..099993b
--- /dev/null
+++ b/hardware/fw/packet_interface.c
@@ -0,0 +1,46 @@
+
+#include "packet_interface.h"
+#include "cobs.h"
+
+void usart2_isr(void) {
+    TRACING_SET(TR_HOST_IF_USART_IRQ);
+    static struct cobs_decode_state host_cobs_state = {0};
+    if (USART2_SR & USART_SR_ORE) { /* Overrun handling */
+        LOG_PRINTF("USART2 data register overrun\n");
+        /* Clear interrupt flag */
+        (void)USART2_DR; /* FIXME make sure this read is not optimized out */
+        host_packet_length = -1;
+        TRACING_CLEAR(TR_HOST_IF_USART_IRQ);
+        return;
+    }
+
+    uint8_t data = USART2_DR; /* This automatically acknowledges the IRQ */
+
+    if (host_packet_length) {
+        LOG_PRINTF("USART2 COBS buffer overrun\n");
+        host_packet_length = -1;
+        TRACING_CLEAR(TR_HOST_IF_USART_IRQ);
+        return;
+    }
+
+    ssize_t rv = cobs_decode_incremental(&host_cobs_state, (char *)host_packet_buf, sizeof(host_packet_buf), data);
+    if (rv == -2) {
+        LOG_PRINTF("Host interface COBS packet too large\n");
+        host_packet_length = -1;
+    } else if (rv == -3) {
+        LOG_PRINTF("Got double null byte from host\n");
+    } else if (rv < 0) {
+        LOG_PRINTF("Host interface COBS framing error\n");
+        host_packet_length = -1;
+    } else if (rv > 0) {
+        host_packet_length = rv;
+    } /* else just return and wait for next byte */
+    TRACING_CLEAR(TR_HOST_IF_USART_IRQ);
+}
+
+void send_packet(struct dma_usart_file *f, const uint8_t *data, size_t len) {
+    /* ignore return value as putf is blocking and always succeeds */
+    (void)cobs_encode_incremental(f, putf, (char *)data, len);
+    flush(f);
+}
+
diff --git a/hardware/fw/packet_interface.h b/hardware/fw/packet_interface.h
new file mode 100644
index 0000000..dbace62
--- /dev/null
+++ b/hardware/fw/packet_interface.h
@@ -0,0 +1,6 @@
+#ifndef __PACKET_INTERFACE_H__
+#define __PACKET_INTERFACE_H__
+
+void send_packet(struct dma_usart_file *f, const uint8_t *data, size_t len);
+
+#endif
diff --git a/hardware/fw/reader.py b/hardware/fw/reader.py
new file mode 100644
index 0000000..c60edb7
--- /dev/null
+++ b/hardware/fw/reader.py
@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+
+import struct
+
+import sqlite3
+
+import serial
+from cobs import cobs
+
+if __name__ == '__main__':
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-b', '--baudrate', type=int, default=250000)
+    parser.add_argument('port')
+    parser.add_argument('dbfile')
+    args = parser.parse_args()
+
+    db = sqlite3.connect(args.db)
+    ser = serial.Serial(args.port, args.baudrate)
+
+    while True:
+        packet = ser.read_until(b'\0')
+        try:
+            packet = cobs.decode(packet)
+            crc, seq, struct.decode('IBxH', packet[:8])
+
+        except Exception as e:
+            print(e)
+
diff --git a/hardware/fw/scope.gdb b/hardware/fw/scope.gdb
new file mode 100644
index 0000000..01366fa
--- /dev/null
+++ b/hardware/fw/scope.gdb
@@ -0,0 +1,12 @@
+target remote 192.168.178.103:3334
+set pagination off
+file main.elf
+load
+
+break gdb_dump
+command 1
+    dump binary value /tmp/scope_dump.bin adc_buf
+    continue
+end
+
+continue
diff --git a/hardware/fw/serial.c b/hardware/fw/serial.c
new file mode 100644
index 0000000..ae05fc9
--- /dev/null
+++ b/hardware/fw/serial.c
@@ -0,0 +1,251 @@
+#include "global.h"

+#include "serial.h"

+#include "cobs.h"

+

+#include <string.h>

+#include <stdarg.h>

+#include <stdlib.h>

+

+volatile struct dma_tx_buf usart_tx_buf;

+

+static uint32_t tx_overruns=0, rx_overruns=0;

+static uint32_t rx_framing_errors=0, rx_protocol_errors=0;

+

+static struct cobs_decode_state cobs_state;

+

+static volatile uint8_t rx_buf[32];

+

+

+static void usart_schedule_dma(void);

+static int usart_putc_nonblocking(uint8_t c);

+

+

+void usart_dma_reset() {

+    usart_tx_buf.xfr_start = -1;

+    usart_tx_buf.xfr_end = 0;

+    usart_tx_buf.wr_pos = 0;

+    usart_tx_buf.wr_idx = 0;

+    usart_tx_buf.xfr_next = 0;

+    usart_tx_buf.wraparound = false;

+    usart_tx_buf.ack = true;

+

+    for (size_t i=0; i<ARRAY_LEN(usart_tx_buf.packet_end); i++)

+        usart_tx_buf.packet_end[i] = -1;

+

+    cobs_decode_incremental_initialize(&cobs_state);

+}

+

+void usart_dma_init() {

+    usart_dma_reset();

+

+    /* Configure DMA 1 Channel 2 to handle uart transmission */

+    DMA1_Channel2->CPAR = (uint32_t)&(USART1->TDR);

+    DMA1_Channel2->CCR = (0<<DMA_CCR_PL_Pos)

+        | DMA_CCR_DIR

+        | (0<<DMA_CCR_MSIZE_Pos) /* 8 bit */

+        | (0<<DMA_CCR_PSIZE_Pos) /* 8 bit */

+        | DMA_CCR_MINC

+        | DMA_CCR_TCIE; /* Enable transfer complete interrupt. */

+

+    DMA1_Channel3->CMAR = (uint32_t)&(CRC->DR);

+    DMA1_Channel3->CCR = (1<<DMA_CCR_PL_Pos)

+        | (0<<DMA_CCR_MSIZE_Pos) /* 8 bit */

+        | (0<<DMA_CCR_PSIZE_Pos) /* 8 bit */

+        | DMA_CCR_PINC

+        | DMA_CCR_TCIE; /* Enable transfer complete interrupt. */

+

+    /* triggered on transfer completion. We use this to process the ADC data */

+    NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);

+    NVIC_SetPriority(DMA1_Channel2_3_IRQn, 2<<5);

+

+    USART1->CR1 = /* 8-bit -> M1, M0 clear */

+        /* OVER8 clear. Use default 16x oversampling */

+        /* CMIF clear */

+          USART_CR1_MME

+        /* WAKE clear */

+        /* PCE, PS clear */

+        | USART_CR1_RXNEIE /* Enable receive interrupt */

+        /* other interrupts clear */

+        | USART_CR1_TE

+        | USART_CR1_RE;

+    /* Set divider for 115.2kBd @48MHz system clock. */

+    //USART1->BRR = 417;

+    

+    //USART1->BRR = 48; /* 1MBd */

+    //USART1->BRR = 96; /* 500kBd */

+    USART1->BRR = 192; /* 250kBd */

+    //USART1->BRR = 208; /* 230400 */

+

+    USART1->CR2 = USART_CR2_TXINV | USART_CR2_RXINV;

+

+    USART1->CR3 |= USART_CR3_DMAT; /* TX DMA enable */

+

+    /* Enable receive interrupt */

+    NVIC_EnableIRQ(USART1_IRQn);

+    NVIC_SetPriority(USART1_IRQn, 1<<5);

+

+    /* And... go! */

+    USART1->CR1 |= USART_CR1_UE;

+}

+

+void USART1_IRQHandler() {

+    uint32_t isr = USART1->ISR;

+

+    if (isr & USART_ISR_ORE) {

+        USART1->ICR = USART_ICR_ORECF;

+        rx_overruns++;

+        return;

+    }

+

+    if (isr & USART_ISR_RXNE) {

+        uint8_t c = USART1->RDR;

+

+        int rc = cobs_decode_incremental(&cobs_state, (char *)rx_buf, sizeof(rx_buf), c);

+        if (rc == 0) /* packet still incomplete */

+            return;

+

+        if (rc < 0) {

+            rx_framing_errors++;

+            return;

+        }

+        

+        /* A complete frame received */

+        if (rc != 2) {

+            rx_protocol_errors++;

+            return;

+        }

+

+        volatile struct ctrl_pkt *pkt = (volatile struct ctrl_pkt *)rx_buf;

+

+        switch (pkt->type) {

+            case CTRL_PKT_RESET:

+                usart_dma_reset();

+                break;

+

+            case CTRL_PKT_ACK:

+                usart_tx_buf.ack = true;

+                if (!(DMA1_Channel2->CCR & DMA_CCR_EN))

+                    usart_schedule_dma();

+                break;

+

+            default:

+                rx_protocol_errors++;

+        }

+        return;

+    }

+}

+

+

+void usart_schedule_dma() {

+    volatile struct dma_tx_buf *buf = &usart_tx_buf;

+

+    ssize_t xfr_start, xfr_end, xfr_len;

+    if (buf->wraparound) {

+        buf->wraparound = false;

+        xfr_start = 0;

+        xfr_len = buf->xfr_end;

+        xfr_end = buf->xfr_end;

+

+    } else if (buf->ack) {

+        if (buf->packet_end[buf->xfr_next] == -1)

+            return; /* Nothing to trasnmit */

+

+        buf->ack = false;

+

+        xfr_start = buf->xfr_end;

+        xfr_end = buf->packet_end[buf->xfr_next];

+        buf->packet_end[buf->xfr_next] = -1;

+        buf->xfr_next = (buf->xfr_next + 1) % ARRAY_LEN(buf->packet_end);

+

+        if (xfr_end > xfr_start) { /* no wraparound */

+            xfr_len = xfr_end - xfr_start;

+

+        } else { /* wraparound */

+            if (xfr_end != 0)

+                buf->wraparound = true;

+            xfr_len = sizeof(buf->data) - xfr_start;

+        }

+

+    } else {

+        /* retransmit */

+        /* First, send a zero to delimit any garbage from the following good packet */

+        USART1->TDR = 0x00;

+

+        xfr_start = buf->xfr_start;

+        xfr_end = buf->xfr_end;

+

+        if (xfr_end > xfr_start) { /* no wraparound */

+            xfr_len = xfr_end - xfr_start;

+

+        } else { /* wraparound */

+            if (xfr_end != 0)

+                buf->wraparound = true;

+            xfr_len = sizeof(buf->data) - xfr_start;

+        }

+

+        leds.error = 250;

+    }

+

+    buf->xfr_start = xfr_start;

+    buf->xfr_end = xfr_end;

+

+    /* initiate transmission of new buffer */

+    DMA1_Channel2->CMAR = (uint32_t)(buf->data + xfr_start);

+    DMA1_Channel2->CNDTR = xfr_len;

+    DMA1_Channel2->CCR |= DMA_CCR_EN;

+}

+

+int usart_putc_nonblocking(uint8_t c) {

+    volatile struct dma_tx_buf *buf = &usart_tx_buf;

+

+    if (buf->wr_pos == buf->xfr_start)

+        return -EBUSY;

+

+    buf->data[buf->wr_pos] = c;

+    buf->wr_pos = (buf->wr_pos + 1) % sizeof(buf->data);

+    return 0;

+}

+

+

+void DMA1_Channel2_3_IRQHandler(void) {

+    /* Transfer complete */

+    DMA1->IFCR |= DMA_IFCR_CTCIF2;

+

+    DMA1_Channel2->CCR &= ~DMA_CCR_EN;

+    if (usart_tx_buf.wraparound)

+        usart_schedule_dma();

+}

+

+/* len is the packet length including headers */

+int usart_send_packet_nonblocking(struct ll_pkt *pkt, size_t pkt_len) {

+

+    if (usart_tx_buf.packet_end[usart_tx_buf.wr_idx] != -1) {

+        /* Find a free slot for this packet */

+        tx_overruns++;

+        return -EBUSY;

+    }

+

+    pkt->pid = usart_tx_buf.wr_idx;

+    pkt->_pad = usart_tx_buf.xfr_next;

+

+    /* make the value this wonky-ass CRC implementation produces match zlib etc. */

+    CRC->CR = CRC_CR_REV_OUT | (1<<CRC_CR_REV_IN_Pos) | CRC_CR_RESET;

+    for (size_t i=offsetof(struct ll_pkt, pid); i<pkt_len; i++)

+        CRC->DR = ((uint8_t *)pkt)[i];

+

+    pkt->crc32 = ~CRC->DR;

+

+    int rc = cobs_encode_usart((int (*)(char))usart_putc_nonblocking, (char *)pkt, pkt_len);

+    if (rc)

+        return rc;

+

+    usart_tx_buf.packet_end[usart_tx_buf.wr_idx] = usart_tx_buf.wr_pos;

+    usart_tx_buf.wr_idx = (usart_tx_buf.wr_idx + 1) % ARRAY_LEN(usart_tx_buf.packet_end);

+

+    leds.usb = 100;

+

+    if (!(DMA1_Channel2->CCR & DMA_CCR_EN))

+        usart_schedule_dma();

+    return 0;

+}

+

diff --git a/hardware/fw/serial.h b/hardware/fw/serial.h
new file mode 100644
index 0000000..8cec089
--- /dev/null
+++ b/hardware/fw/serial.h
@@ -0,0 +1,75 @@
+/*

+ * This file is part of the libusbhost library

+ * hosted at http://github.com/libusbhost/libusbhost

+ *

+ * Copyright (C) 2015 Amir Hammad <amir.hammad@hotmail.com>

+ *

+ *

+ * libusbhost is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU Lesser General Public License as published by

+ * the Free Software Foundation, either version 3 of the License, or

+ * (at your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public License

+ * along with this library.  If not, see <http://www.gnu.org/licenses/>.

+ *

+ */

+

+#ifndef __SERIAL_H__

+#define __SERIAL_H__

+

+#include <stdint.h>

+#include <stdarg.h>

+#include <errno.h>

+#include <stdbool.h>

+

+#include "global.h"

+

+struct dma_tx_buf {

+    /* The following fields are accessed only from DMA ISR */

+    ssize_t xfr_start; /* Start index of running DMA transfer */

+    ssize_t xfr_end; /* End index of running DMA transfer plus one */

+    bool wraparound;

+    ssize_t xfr_next;

+    bool ack;

+

+

+    /* The following fields are written only from non-interrupt code */

+    ssize_t wr_pos; /* Next index to be written */

+    ssize_t wr_idx;

+    ssize_t packet_end[8];

+

+    /* The following may be accessed by anything */

+    uint8_t data[512];

+};

+

+struct __attribute__((__packed__)) ll_pkt {

+    uint32_t crc32;

+    /* CRC computed over entire packet starting here */

+    uint8_t pid;

+    uint8_t _pad;

+    uint8_t data[];

+};

+

+enum ctrl_pkt_type {

+    CTRL_PKT_RESET = 1,

+    CTRL_PKT_ACK = 2,

+};

+

+struct __attribute__((__packed__)) ctrl_pkt {

+    uint8_t type;

+    uint8_t orig_id;

+};

+

+extern volatile struct dma_tx_buf usart_tx_buf;

+

+void usart_dma_init(void);

+int usart_send_packet_nonblocking(struct ll_pkt *pkt, size_t pkt_len);

+int usart_ack_packet(uint8_t idx);

+

+#endif // __SERIAL_H__

diff --git a/hardware/fw/startup_stm32f030x6.s b/hardware/fw/startup_stm32f030x6.s
new file mode 100644
index 0000000..2f0eb42
--- /dev/null
+++ b/hardware/fw/startup_stm32f030x6.s
@@ -0,0 +1,273 @@
+/**

+  ******************************************************************************

+  * @file      startup_stm32f030x6.s

+  * copied from: STM32Cube/Drivers/CMSIS/Device/ST/STM32F0xx/Source/Templates/gcc

+  * @author    MCD Application Team

+  * @version   V2.3.1

+  * @date      04-November-2016

+  * @brief     STM32F030x4/STM32F030x6 devices vector table for Atollic TrueSTUDIO toolchain.

+  *            This module performs:

+  *                - Set the initial SP

+  *                - Set the initial PC == Reset_Handler,

+  *                - Set the vector table entries with the exceptions ISR address

+  *                - Branches to main in the C library (which eventually

+  *                  calls main()).

+  *            After Reset the Cortex-M0 processor is in Thread mode,

+  *            priority is Privileged, and the Stack is set to Main.

+  ******************************************************************************

+  * 

+  * Redistribution and use in source and binary forms, with or without modification,

+  * are permitted provided that the following conditions are met:

+  *   1. Redistributions of source code must retain the above copyright notice,

+  *      this list of conditions and the following disclaimer.

+  *   2. Redistributions in binary form must reproduce the above copyright notice,

+  *      this list of conditions and the following disclaimer in the documentation

+  *      and/or other materials provided with the distribution.

+  *   3. Neither the name of STMicroelectronics nor the names of its contributors

+  *      may be used to endorse or promote products derived from this software

+  *      without specific prior written permission.

+  *

+  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

+  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

+  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

+  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

+  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

+  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

+  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+  *

+  ******************************************************************************

+  */

+

+  .syntax unified

+  .cpu cortex-m0

+  .fpu softvfp

+  .thumb

+

+.global g_pfnVectors

+.global Default_Handler

+

+/* start address for the initialization values of the .data section.

+defined in linker script */

+.word _sidata

+/* start address for the .data section. defined in linker script */

+.word _sdata

+/* end address for the .data section. defined in linker script */

+.word _edata

+/* start address for the .bss section. defined in linker script */

+.word _sbss

+/* end address for the .bss section. defined in linker script */

+.word _ebss

+

+  .section .text.Reset_Handler

+  .weak Reset_Handler

+  .type Reset_Handler, %function

+Reset_Handler:

+  ldr   r0, =_estack

+  mov   sp, r0          /* set stack pointer */

+

+/* Copy the data segment initializers from flash to SRAM */

+  movs r1, #0

+  b LoopCopyDataInit

+

+CopyDataInit:

+  ldr r3, =_sidata

+  ldr r3, [r3, r1]

+  str r3, [r0, r1]

+  adds r1, r1, #4

+

+LoopCopyDataInit:

+  ldr r0, =_sdata

+  ldr r3, =_edata

+  adds r2, r0, r1

+  cmp r2, r3

+  bcc CopyDataInit

+  ldr r2, =_sbss

+  b LoopFillZerobss

+/* Zero fill the bss segment. */

+FillZerobss:

+  movs r3, #0

+  str  r3, [r2]

+  adds r2, r2, #4

+

+

+LoopFillZerobss:

+  ldr r3, = _ebss

+  cmp r2, r3

+  bcc FillZerobss

+

+/* Call the clock system intitialization function.*/

+  bl  SystemInit

+/* Call static constructors */

+//  bl __libc_init_array

+/* Call the application's entry point.*/

+  bl main

+

+LoopForever:

+    b LoopForever

+

+

+.size Reset_Handler, .-Reset_Handler

+

+/**

+ * @brief  This is the code that gets called when the processor receives an

+ *         unexpected interrupt.  This simply enters an infinite loop, preserving

+ *         the system state for examination by a debugger.

+ *

+ * @param  None

+ * @retval : None

+*/

+    .section .text.Default_Handler,"ax",%progbits

+Default_Handler:

+Infinite_Loop:

+  b Infinite_Loop

+  .size Default_Handler, .-Default_Handler

+/******************************************************************************

+*

+* The minimal vector table for a Cortex M0.  Note that the proper constructs

+* must be placed on this to ensure that it ends up at physical address

+* 0x0000.0000.

+*

+******************************************************************************/

+   .section .isr_vector,"a",%progbits

+  .type g_pfnVectors, %object

+  .size g_pfnVectors, .-g_pfnVectors

+

+

+g_pfnVectors:

+  .word  _estack

+  .word  Reset_Handler

+  .word  NMI_Handler

+  .word  HardFault_Handler

+  .word  0

+  .word  0

+  .word  0

+  .word  0

+  .word  0

+  .word  0

+  .word  0

+  .word  SVC_Handler

+  .word  0

+  .word  0

+  .word  PendSV_Handler

+  .word  SysTick_Handler

+  .word  WWDG_IRQHandler                   /* Window WatchDog              */

+  .word  0                                 /* Reserved                     */

+  .word  RTC_IRQHandler                    /* RTC through the EXTI line    */

+  .word  FLASH_IRQHandler                  /* FLASH                        */

+  .word  RCC_IRQHandler                    /* RCC                          */

+  .word  EXTI0_1_IRQHandler                /* EXTI Line 0 and 1            */

+  .word  EXTI2_3_IRQHandler                /* EXTI Line 2 and 3            */

+  .word  EXTI4_15_IRQHandler               /* EXTI Line 4 to 15            */

+  .word  0                                 /* Reserved                     */

+  .word  DMA1_Channel1_IRQHandler          /* DMA1 Channel 1               */

+  .word  DMA1_Channel2_3_IRQHandler        /* DMA1 Channel 2 and Channel 3 */

+  .word  DMA1_Channel4_5_IRQHandler        /* DMA1 Channel 4 and Channel 5 */

+  .word  ADC1_IRQHandler                   /* ADC1                         */

+  .word  TIM1_BRK_UP_TRG_COM_IRQHandler    /* TIM1 Break, Update, Trigger and Commutation */

+  .word  TIM1_CC_IRQHandler                /* TIM1 Capture Compare         */

+  .word  0                                 /* Reserved                     */

+  .word  TIM3_IRQHandler                   /* TIM3                         */

+  .word  0                                 /* Reserved                     */

+  .word  0                                 /* Reserved                     */

+  .word  TIM14_IRQHandler                  /* TIM14                        */

+  .word  0                                 /* Reserved                     */

+  .word  TIM16_IRQHandler                  /* TIM16                        */

+  .word  TIM17_IRQHandler                  /* TIM17                        */

+  .word  I2C1_IRQHandler                   /* I2C1                         */

+  .word  0                                 /* Reserved                     */

+  .word  SPI1_IRQHandler                   /* SPI1                         */

+  .word  0                                 /* Reserved                     */

+  .word  USART1_IRQHandler                 /* USART1                       */

+  .word  0                                 /* Reserved                     */

+  .word  0                                 /* Reserved                     */

+  .word  0                                 /* Reserved                     */

+  .word  0                                 /* Reserved                     */

+

+/*******************************************************************************

+*

+* Provide weak aliases for each Exception handler to the Default_Handler.

+* As they are weak aliases, any function with the same name will override

+* this definition.

+*

+*******************************************************************************/

+

+  .weak      NMI_Handler

+  .thumb_set NMI_Handler,Default_Handler

+

+  .weak      HardFault_Handler

+  .thumb_set HardFault_Handler,Default_Handler

+

+  .weak      SVC_Handler

+  .thumb_set SVC_Handler,Default_Handler

+

+  .weak      PendSV_Handler

+  .thumb_set PendSV_Handler,Default_Handler

+

+  .weak      SysTick_Handler

+  .thumb_set SysTick_Handler,Default_Handler

+

+  .weak      WWDG_IRQHandler

+  .thumb_set WWDG_IRQHandler,Default_Handler

+

+  .weak      RTC_IRQHandler

+  .thumb_set RTC_IRQHandler,Default_Handler

+

+  .weak      FLASH_IRQHandler

+  .thumb_set FLASH_IRQHandler,Default_Handler

+

+  .weak      RCC_IRQHandler

+  .thumb_set RCC_IRQHandler,Default_Handler

+

+  .weak      EXTI0_1_IRQHandler

+  .thumb_set EXTI0_1_IRQHandler,Default_Handler

+

+  .weak      EXTI2_3_IRQHandler

+  .thumb_set EXTI2_3_IRQHandler,Default_Handler

+

+  .weak      EXTI4_15_IRQHandler

+  .thumb_set EXTI4_15_IRQHandler,Default_Handler

+

+  .weak      DMA1_Channel1_IRQHandler

+  .thumb_set DMA1_Channel1_IRQHandler,Default_Handler

+

+  .weak      DMA1_Channel2_3_IRQHandler

+  .thumb_set DMA1_Channel2_3_IRQHandler,Default_Handler

+

+  .weak      DMA1_Channel4_5_IRQHandler

+  .thumb_set DMA1_Channel4_5_IRQHandler,Default_Handler

+

+  .weak      ADC1_IRQHandler

+  .thumb_set ADC1_IRQHandler,Default_Handler

+

+  .weak      TIM1_BRK_UP_TRG_COM_IRQHandler

+  .thumb_set TIM1_BRK_UP_TRG_COM_IRQHandler,Default_Handler

+

+  .weak      TIM1_CC_IRQHandler

+  .thumb_set TIM1_CC_IRQHandler,Default_Handler

+

+  .weak      TIM3_IRQHandler

+  .thumb_set TIM3_IRQHandler,Default_Handler

+

+  .weak      TIM14_IRQHandler

+  .thumb_set TIM14_IRQHandler,Default_Handler

+

+  .weak      TIM16_IRQHandler

+  .thumb_set TIM16_IRQHandler,Default_Handler

+

+  .weak      TIM17_IRQHandler

+  .thumb_set TIM17_IRQHandler,Default_Handler

+

+  .weak      I2C1_IRQHandler

+  .thumb_set I2C1_IRQHandler,Default_Handler

+

+  .weak      SPI1_IRQHandler

+  .thumb_set SPI1_IRQHandler,Default_Handler

+

+  .weak      USART1_IRQHandler

+  .thumb_set USART1_IRQHandler,Default_Handler

+

+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

+

diff --git a/hardware/fw/stm32_flash.ld b/hardware/fw/stm32_flash.ld
new file mode 100644
index 0000000..cba7577
--- /dev/null
+++ b/hardware/fw/stm32_flash.ld
@@ -0,0 +1,136 @@
+

+ENTRY(Reset_Handler)

+

+MEMORY {

+  FLASH (rx): ORIGIN = 0x08000000, LENGTH = 0x3C00

+  CONFIGFLASH (rw): ORIGIN = 0x08003C00, LENGTH = 0x400

+  RAM (xrw):  ORIGIN = 0x20000000, LENGTH = 4K

+}

+

+/* highest address of the user mode stack */

+_estack = 0x20001000;

+

+SECTIONS {

+    /* for Cortex devices, the beginning of the startup code is stored in the .isr_vector section, which goes to FLASH */

+    .isr_vector : {

+	. = ALIGN(4);

+        KEEP(*(.isr_vector))            /* Startup code */

+	. = ALIGN(4);

+    } >FLASH

+    

+    /* the program code is stored in the .text section, which goes to Flash */

+    .text : {

+	    . = ALIGN(4);

+	    

+        *(.text)                   /* normal code */

+        *(.text.*)                 /* -ffunction-sections code */

+        *(.rodata)                 /* read-only data (constants) */

+        *(.rodata*)                /* -fdata-sections read only data */

+        *(.glue_7)                 /* TBD - needed ? */

+        *(.glue_7t)                /* TBD - needed ? */

+

+        *(.source_tarball)

+

+        /* Necessary KEEP sections (see http://sourceware.org/ml/newlib/2005/msg00255.html) */

+        KEEP (*(.init))

+        KEEP (*(.fini))

+        KEEP (*(.source_tarball))

+

+	    . = ALIGN(4);

+        _etext = .;

+	    /* This is used by the startup in order to initialize the .data section */

+        _sidata = _etext;

+    } >FLASH

+

+    /*

+    .configflash : {

+        . = ALIGN(0x400);

+        *(.configdata)

+        _econfig = .;

+    } >FLASH

+    */

+    

+    /* This is the initialized data section

+    The program executes knowing that the data is in the RAM

+    but the loader puts the initial values in the FLASH (inidata).

+    It is one task of the startup to copy the initial values from FLASH to RAM. */

+    .data  : AT ( _sidata ) {

+	    . = ALIGN(4);

+        /* This is used by the startup in order to initialize the .data secion */

+        _sdata = . ;

+        _data = . ;

+        

+        *(.data)

+        *(.data.*)

+        *(.RAMtext)

+

+	    . = ALIGN(4);

+	    /* This is used by the startup in order to initialize the .data secion */

+   	    _edata = . ;

+    } >RAM

+    

+    /* This is the uninitialized data section */

+    .bss : {

+	    . = ALIGN(4);

+        /* This is used by the startup in order to initialize the .bss secion */

+        _sbss = .;

+        _bss = .;

+        

+        *(.bss)

+        *(.bss.*) /* patched by elias - allows the use of -fdata-sections */

+        *(COMMON)

+        

+	    . = ALIGN(4);

+	    /* This is used by the startup in order to initialize the .bss secion */

+   	 _ebss = . ;

+    } >RAM

+    

+    PROVIDE ( end = _ebss);

+    PROVIDE (_end = _ebss);

+    

+    __exidx_start = .;

+    __exidx_end = .;

+    

+    /* after that it's only debugging information. */

+    

+    /* remove the debugging information from the standard libraries */

+/*    /DISCARD/ : {

+        libc.a ( * )

+        libm.a ( * )

+        libgcc.a ( * )

+    }*/

+

+    /* Stabs debugging sections.  */

+    .stab          0 : { *(.stab) }

+    .stabstr       0 : { *(.stabstr) }

+    .stab.excl     0 : { *(.stab.excl) }

+    .stab.exclstr  0 : { *(.stab.exclstr) }

+    .stab.index    0 : { *(.stab.index) }

+    .stab.indexstr 0 : { *(.stab.indexstr) }

+    .comment       0 : { *(.comment) }

+    /* DWARF debug sections.

+       Symbols in the DWARF debugging sections are relative to the beginning

+       of the section so we begin them at 0.  */

+    /* DWARF 1 */

+    .debug          0 : { *(.debug) }

+    .line           0 : { *(.line) }

+    /* GNU DWARF 1 extensions */

+    .debug_srcinfo  0 : { *(.debug_srcinfo) }

+    .debug_sfnames  0 : { *(.debug_sfnames) }

+    /* DWARF 1.1 and DWARF 2 */

+    .debug_aranges  0 : { *(.debug_aranges) }

+    .debug_pubnames 0 : { *(.debug_pubnames) }

+    /* DWARF 2 */

+    .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }

+    .debug_abbrev   0 : { *(.debug_abbrev) }

+    .debug_line     0 : { *(.debug_line) }

+    .debug_frame    0 : { *(.debug_frame) }

+    .debug_str      0 : { *(.debug_str) }

+    .debug_loc      0 : { *(.debug_loc) }

+    .debug_macinfo  0 : { *(.debug_macinfo) }

+    /* SGI/MIPS DWARF 2 extensions */

+    .debug_weaknames 0 : { *(.debug_weaknames) }

+    .debug_funcnames 0 : { *(.debug_funcnames) }

+    .debug_typenames 0 : { *(.debug_typenames) }

+    .debug_varnames  0 : { *(.debug_varnames) }

+}

diff --git a/hardware/fw/system_stm32f0xx.c b/hardware/fw/system_stm32f0xx.c
new file mode 100644
index 0000000..a43c3d6
--- /dev/null
+++ b/hardware/fw/system_stm32f0xx.c
@@ -0,0 +1,336 @@
+/**

+  ******************************************************************************

+  * @file    system_stm32f0xx.c

+  * copied from: STM32Cube/Drivers/CMSIS/Device/ST/STM32F0xx/Source/Templates

+  * @author  MCD Application Team

+  * @version V2.3.1

+  * @date    04-November-2016

+  * @brief   CMSIS Cortex-M0 Device Peripheral Access Layer System Source File.

+  *

+  * 1. This file provides two functions and one global variable to be called from

+  *    user application:

+  *      - SystemInit(): This function is called at startup just after reset and 

+  *                      before branch to main program. This call is made inside

+  *                      the "startup_stm32f0xx.s" file.

+  *

+  *      - SystemCoreClock variable: Contains the core clock (HCLK), it can be used

+  *                                  by the user application to setup the SysTick

+  *                                  timer or configure other parameters.

+  *

+  *      - SystemCoreClockUpdate(): Updates the variable SystemCoreClock and must

+  *                                 be called whenever the core clock is changed

+  *                                 during program execution.

+  *

+  * 2. After each device reset the HSI (8 MHz) is used as system clock source.

+  *    Then SystemInit() function is called, in "startup_stm32f0xx.s" file, to

+  *    configure the system clock before to branch to main program.

+  *

+  * 3. This file configures the system clock as follows:

+  *=============================================================================

+  *                         Supported STM32F0xx device

+  *-----------------------------------------------------------------------------

+  *        System Clock source                    | HSI

+  *-----------------------------------------------------------------------------

+  *        SYSCLK(Hz)                             | 8000000

+  *-----------------------------------------------------------------------------

+  *        HCLK(Hz)                               | 8000000

+  *-----------------------------------------------------------------------------

+  *        AHB Prescaler                          | 1

+  *-----------------------------------------------------------------------------

+  *        APB1 Prescaler                         | 1

+  *-----------------------------------------------------------------------------

+  *=============================================================================

+  ******************************************************************************

+  * @attention

+  *

+  * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>

+  *

+  * Redistribution and use in source and binary forms, with or without modification,

+  * are permitted provided that the following conditions are met:

+  *   1. Redistributions of source code must retain the above copyright notice,

+  *      this list of conditions and the following disclaimer.

+  *   2. Redistributions in binary form must reproduce the above copyright notice,

+  *      this list of conditions and the following disclaimer in the documentation

+  *      and/or other materials provided with the distribution.

+  *   3. Neither the name of STMicroelectronics nor the names of its contributors

+  *      may be used to endorse or promote products derived from this software

+  *      without specific prior written permission.

+  *

+  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

+  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

+  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

+  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

+  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

+  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

+  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+  *

+  ******************************************************************************

+  */

+

+/** @addtogroup CMSIS

+  * @{

+  */

+

+/** @addtogroup stm32f0xx_system

+  * @{

+  */

+

+/** @addtogroup STM32F0xx_System_Private_Includes

+  * @{

+  */

+

+#include "stm32f0xx.h"

+

+/**

+  * @}

+  */

+

+/** @addtogroup STM32F0xx_System_Private_TypesDefinitions

+  * @{

+  */

+

+/**

+  * @}

+  */

+

+/** @addtogroup STM32F0xx_System_Private_Defines

+  * @{

+  */

+#if !defined  (HSE_VALUE) 

+  #define HSE_VALUE    ((uint32_t)8000000) /*!< Default value of the External oscillator in Hz.

+                                                This value can be provided and adapted by the user application. */

+#endif /* HSE_VALUE */

+

+#if !defined  (HSI_VALUE)

+  #define HSI_VALUE    ((uint32_t)8000000) /*!< Default value of the Internal oscillator in Hz.

+                                                This value can be provided and adapted by the user application. */

+#endif /* HSI_VALUE */

+

+#if !defined (HSI48_VALUE)

+#define HSI48_VALUE    ((uint32_t)48000000) /*!< Default value of the HSI48 Internal oscillator in Hz.

+                                                 This value can be provided and adapted by the user application. */

+#endif /* HSI48_VALUE */

+/**

+  * @}

+  */

+

+/** @addtogroup STM32F0xx_System_Private_Macros

+  * @{

+  */

+

+/**

+  * @}

+  */

+

+/** @addtogroup STM32F0xx_System_Private_Variables

+  * @{

+  */

+  /* This variable is updated in three ways:

+      1) by calling CMSIS function SystemCoreClockUpdate()

+      2) by calling HAL API function HAL_RCC_GetHCLKFreq()

+      3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency

+         Note: If you use this function to configure the system clock there is no need to

+               call the 2 first functions listed above, since SystemCoreClock variable is 

+               updated automatically.

+  */

+uint32_t SystemCoreClock = 8000000;

+

+const uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};

+const uint8_t APBPrescTable[8]  = {0, 0, 0, 0, 1, 2, 3, 4};

+

+/**

+  * @}

+  */

+

+/** @addtogroup STM32F0xx_System_Private_FunctionPrototypes

+  * @{

+  */

+

+/**

+  * @}

+  */

+

+/** @addtogroup STM32F0xx_System_Private_Functions

+  * @{

+  */

+

+/**

+  * @brief  Setup the microcontroller system.

+  *         Initialize the default HSI clock source, vector table location and the PLL configuration is reset.

+  * @param  None

+  * @retval None

+  */

+void SystemInit(void)

+{

+  /* Reset the RCC clock configuration to the default reset state ------------*/

+  /* Set HSION bit */

+  RCC->CR |= (uint32_t)0x00000001U;

+

+#if defined (STM32F051x8) || defined (STM32F058x8)

+  /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE and MCOSEL[2:0] bits */

+  RCC->CFGR &= (uint32_t)0xF8FFB80CU;

+#else

+  /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits */

+  RCC->CFGR &= (uint32_t)0x08FFB80CU;

+#endif /* STM32F051x8 or STM32F058x8 */

+  

+  /* Reset HSEON, CSSON and PLLON bits */

+  RCC->CR &= (uint32_t)0xFEF6FFFFU;

+

+  /* Reset HSEBYP bit */

+  RCC->CR &= (uint32_t)0xFFFBFFFFU;

+

+  /* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */

+  RCC->CFGR &= (uint32_t)0xFFC0FFFFU;

+

+  /* Reset PREDIV[3:0] bits */

+  RCC->CFGR2 &= (uint32_t)0xFFFFFFF0U;

+

+#if defined (STM32F072xB) || defined (STM32F078xx)

+  /* Reset USART2SW[1:0], USART1SW[1:0], I2C1SW, CECSW, USBSW and ADCSW bits */

+  RCC->CFGR3 &= (uint32_t)0xFFFCFE2CU;

+#elif defined (STM32F071xB)

+  /* Reset USART2SW[1:0], USART1SW[1:0], I2C1SW, CECSW and ADCSW bits */

+  RCC->CFGR3 &= (uint32_t)0xFFFFCEACU;

+#elif defined (STM32F091xC) || defined (STM32F098xx)

+  /* Reset USART3SW[1:0], USART2SW[1:0], USART1SW[1:0], I2C1SW, CECSW and ADCSW bits */

+  RCC->CFGR3 &= (uint32_t)0xFFF0FEACU;

+#elif defined (STM32F030x6) || defined (STM32F030x8) || defined (STM32F031x6) || defined (STM32F038xx) || defined (STM32F030xC)

+  /* Reset USART1SW[1:0], I2C1SW and ADCSW bits */

+  RCC->CFGR3 &= (uint32_t)0xFFFFFEECU;

+#elif defined (STM32F051x8) || defined (STM32F058xx)

+  /* Reset USART1SW[1:0], I2C1SW, CECSW and ADCSW bits */

+  RCC->CFGR3 &= (uint32_t)0xFFFFFEACU;

+#elif defined (STM32F042x6) || defined (STM32F048xx)

+  /* Reset USART1SW[1:0], I2C1SW, CECSW, USBSW and ADCSW bits */

+  RCC->CFGR3 &= (uint32_t)0xFFFFFE2CU;

+#elif defined (STM32F070x6) || defined (STM32F070xB)

+  /* Reset USART1SW[1:0], I2C1SW, USBSW and ADCSW bits */

+  RCC->CFGR3 &= (uint32_t)0xFFFFFE6CU;

+  /* Set default USB clock to PLLCLK, since there is no HSI48 */

+  RCC->CFGR3 |= (uint32_t)0x00000080U;  

+#else

+ #warning "No target selected"

+#endif

+

+  /* Reset HSI14 bit */

+  RCC->CR2 &= (uint32_t)0xFFFFFFFEU;

+

+  /* Disable all interrupts */

+  RCC->CIR = 0x00000000U;

+

+}

+

+/**

+   * @brief  Update SystemCoreClock variable according to Clock Register Values.

+  *         The SystemCoreClock variable contains the core clock (HCLK), it can

+  *         be used by the user application to setup the SysTick timer or configure

+  *         other parameters.

+  *

+  * @note   Each time the core clock (HCLK) changes, this function must be called

+  *         to update SystemCoreClock variable value. Otherwise, any configuration

+  *         based on this variable will be incorrect.

+  *

+  * @note   - The system frequency computed by this function is not the real

+  *           frequency in the chip. It is calculated based on the predefined

+  *           constant and the selected clock source:

+  *

+  *           - If SYSCLK source is HSI, SystemCoreClock will contain the HSI_VALUE(*)

+  *

+  *           - If SYSCLK source is HSE, SystemCoreClock will contain the HSE_VALUE(**)

+  *

+  *           - If SYSCLK source is PLL, SystemCoreClock will contain the HSE_VALUE(**)

+  *             or HSI_VALUE(*) multiplied/divided by the PLL factors.

+  *

+  *         (*) HSI_VALUE is a constant defined in stm32f0xx_hal.h file (default value

+  *             8 MHz) but the real value may vary depending on the variations

+  *             in voltage and temperature.

+  *

+  *         (**) HSE_VALUE is a constant defined in stm32f0xx_hal.h file (default value

+  *              8 MHz), user has to ensure that HSE_VALUE is same as the real

+  *              frequency of the crystal used. Otherwise, this function may

+  *              have wrong result.

+  *

+  *         - The result of this function could be not correct when using fractional

+  *           value for HSE crystal.

+  *

+  * @param  None

+  * @retval None

+  */

+void SystemCoreClockUpdate (void)

+{

+  uint32_t tmp = 0, pllmull = 0, pllsource = 0, predivfactor = 0;

+

+  /* Get SYSCLK source -------------------------------------------------------*/

+  tmp = RCC->CFGR & RCC_CFGR_SWS;

+

+  switch (tmp)

+  {

+    case RCC_CFGR_SWS_HSI:  /* HSI used as system clock */

+      SystemCoreClock = HSI_VALUE;

+      break;

+    case RCC_CFGR_SWS_HSE:  /* HSE used as system clock */

+      SystemCoreClock = HSE_VALUE;

+      break;

+    case RCC_CFGR_SWS_PLL:  /* PLL used as system clock */

+      /* Get PLL clock source and multiplication factor ----------------------*/

+      pllmull = RCC->CFGR & RCC_CFGR_PLLMUL;

+      pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;

+      pllmull = ( pllmull >> 18) + 2;

+      predivfactor = (RCC->CFGR2 & RCC_CFGR2_PREDIV) + 1;

+

+      if (pllsource == RCC_CFGR_PLLSRC_HSE_PREDIV)

+      {

+        /* HSE used as PLL clock source : SystemCoreClock = HSE/PREDIV * PLLMUL */

+        SystemCoreClock = (HSE_VALUE/predivfactor) * pllmull;

+      }

+#if defined(STM32F042x6) || defined(STM32F048xx) || defined(STM32F072xB) || defined(STM32F078xx) || defined(STM32F091xC) || defined(STM32F098xx)

+      else if (pllsource == RCC_CFGR_PLLSRC_HSI48_PREDIV)

+      {

+        /* HSI48 used as PLL clock source : SystemCoreClock = HSI48/PREDIV * PLLMUL */

+        SystemCoreClock = (HSI48_VALUE/predivfactor) * pllmull;

+      }

+#endif /* STM32F042x6 || STM32F048xx || STM32F072xB || STM32F078xx || STM32F091xC || STM32F098xx */

+      else

+      {

+#if defined(STM32F042x6) || defined(STM32F048xx)  || defined(STM32F070x6) \

+ || defined(STM32F078xx) || defined(STM32F071xB)  || defined(STM32F072xB) \

+ || defined(STM32F070xB) || defined(STM32F091xC) || defined(STM32F098xx)  || defined(STM32F030xC)

+        /* HSI used as PLL clock source : SystemCoreClock = HSI/PREDIV * PLLMUL */

+        SystemCoreClock = (HSI_VALUE/predivfactor) * pllmull;

+#else

+        /* HSI used as PLL clock source : SystemCoreClock = HSI/2 * PLLMUL */

+        SystemCoreClock = (HSI_VALUE >> 1) * pllmull;

+#endif /* STM32F042x6 || STM32F048xx || STM32F070x6 || 

+          STM32F071xB || STM32F072xB || STM32F078xx || STM32F070xB ||

+          STM32F091xC || STM32F098xx || STM32F030xC */

+      }

+      break;

+    default: /* HSI used as system clock */

+      SystemCoreClock = HSI_VALUE;

+      break;

+  }

+  /* Compute HCLK clock frequency ----------------*/

+  /* Get HCLK prescaler */

+  tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];

+  /* HCLK clock frequency */

+  SystemCoreClock >>= tmp;

+}

+

+/**

+  * @}

+  */

+

+/**

+  * @}

+  */

+

+/**

+  * @}

+  */

+

+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

+

diff --git a/hardware/fw/test.py b/hardware/fw/test.py
new file mode 100644
index 0000000..cb243a5
--- /dev/null
+++ b/hardware/fw/test.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+
+import serial
+import time
+
+#ser = serial.Serial('/dev/serial/by-id/usb-1a86_USB2.0-Serial-if00-port0', 230400)
+ser = serial.Serial('/dev/serial/by-id/usb-Silicon_Labs_CP2102_USB_to_UART_Bridge_Controller_0001-if00-port0', 250000)
+#while True:
+#    ser.write(bytes(range(256)))
+start = time.time()
+
+last_val = None
+run = 0
+total_errors = 0
+rx_bytes = 0
+last_print = time.time()
+while True:
+    bytes = ser.read(256)
+    for byte in bytes:
+        if last_val is not None and byte != (last_val + 1) % 256:
+            if run > 0:
+                print(f'{time.time()-start:>8.3f} {run} {last_val:02x} {byte:02x}')
+                run = 0
+                total_errors += 1
+        else:
+            run += 1
+        rx_bytes += 1
+
+        if time.time() - last_print > 5:
+            last_print = time.time()
+            print(f'{time.time()-start:>8.3f} {run} [all good] err={total_errors}@rx={rx_bytes}B',
+            f'(rate 1/{rx_bytes/total_errors:.5g})' if total_errors > 0 else 'rate unknown')
+        last_val = byte
+
+#while True:
+#    data = ser.read_until(b'\0')
+#    print(f'{time.time()-start:>8.3f} {len(data)}')
+
+# while True:
+#     data = ser.read(256)
+#     print('YES' if b'\0' in data else 'NO ', data)
diff --git a/hardware/fw/tools/gen_cmsis_exports.py b/hardware/fw/tools/gen_cmsis_exports.py
new file mode 100644
index 0000000..ba3422b
--- /dev/null
+++ b/hardware/fw/tools/gen_cmsis_exports.py
@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+import re
+import os
+
+if __name__ == '__main__':
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('cmsis_device_header', nargs='+', type=argparse.FileType('rb'))
+    args = parser.parse_args()
+    
+    print('#ifndef __GENERATED_CMSIS_HEADER_EXPORTS__')
+    print('#define __GENERATED_CMSIS_HEADER_EXPORTS__')
+    print()
+    for header in args.cmsis_device_header:
+        lines = header.readlines()
+        name = os.path.basename(header.name)
+        print('#include <{}>'.format(name))
+        print()
+
+        print('/* {} */'.format(name))
+        for l in lines:
+            match = re.match(b'^#define (\w+)\s+\W*(\w+_TypeDef|\w+_Type).*$', l)
+            if match:
+                inst, typedef = match.groups()
+                inst, typedef = inst.decode(), typedef.decode()
+                print('{} *{} = {};'.format(typedef, inst.lower(), inst))
+        print()
+    print('#endif//__GENERATED_CMSIS_HEADER_EXPORTS__')
+
diff --git a/hardware/fw/tw_test.c b/hardware/fw/tw_test.c
new file mode 100644
index 0000000..eb41dbe
--- /dev/null
+++ b/hardware/fw/tw_test.c
@@ -0,0 +1,450 @@
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <asm/termbits.h>
+#include <fcntl.h> 
+#include <stdbool.h> 
+#include <stdlib.h> 
+#include <stdio.h> 
+#include <string.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <assert.h>
+#include <sys/epoll.h> 
+#include <time.h>
+
+#include <sqlite3.h>
+
+#include <zlib.h>
+
+int set_interface_attribs (int fd, int baudrate) {
+    struct termios2 tio;
+    memset (&tio, 0, sizeof(tio));
+    if (ioctl (fd, TCGETS2, &tio) != 0) {
+        fprintf(stderr, "Could not request termios for given port\n");
+        return -1;
+    }
+
+    /* FIXME set baudrate */
+
+    tio.c_cflag = (tio.c_cflag & ~CSIZE) | CS8; /* 8 bit */
+    /* disable IGNBRK for mismatched speed tests; otherwise receive break as \000 chars */
+    tio.c_iflag &= ~IGNBRK;     /* disable break processing */
+    tio.c_lflag = 0;            /* no signaling chars, no echo, no canonical processing */
+    tio.c_oflag = 0;            /* no remapping, no delays */
+
+    tio.c_iflag &= ~(IXON | IXOFF | IXANY); /* shut off xon/xoff ctrl */
+
+    tio.c_cflag |= (CLOCAL | CREAD);/* ignore modem controls, enable reading */
+    tio.c_cflag &= ~(PARENB | PARODD); /* no parity */
+    tio.c_cflag &= ~CSTOPB;
+    tio.c_cflag &= ~CRTSCTS;
+
+    tio.c_cflag &= ~(CBAUD | CBAUDEX);
+    tio.c_cflag |= BOTHER;
+    tio.c_ospeed = baudrate;
+    tio.c_cflag &= ~((CBAUD | CBAUDEX) << IBSHIFT);
+    tio.c_cflag |= (B0 << IBSHIFT); /* same as output baudrate */
+
+    tio.c_cc[VMIN]  = 0; /* non-blocking mode */
+    tio.c_cc[VTIME] = 10; /* 1000ms seconds read timeout */
+
+    if (ioctl (fd, TCSETS2, &tio)) {
+        fprintf(stderr, "Could not set serial port attributes: Error %d in tcsetattr (\"%s\")\n", errno, strerror(errno));
+        return -1;
+    }
+    return 0;
+}
+
+ssize_t cobs_decode(char *dst, size_t dstlen, char *src, size_t srclen) {
+    size_t p = 1;
+    size_t c = (unsigned char)src[0];
+    if (c == 0)
+        return -5; /* invalid framing. An empty frame would be [...] 00 01 00, not [...] 00 00 */
+
+    while (p < srclen && src[p]) {
+        char val;
+        c--;
+
+        if (c == 0) {
+            c = (unsigned char)src[p];
+            val = 0;
+        } else {
+            val = src[p];
+        }
+
+        if (p > dstlen)
+            return -4; /* Destination buffer too small */
+        dst[p-1] = val;
+        p++;
+    }
+
+    if (p == srclen)
+        return -2; /* Invalid framing. The terminating null byte should always be present in the input buffer. */
+
+    if (c != 1)
+        return -3; /* Invalid framing. The skip counter does not hit the end of the frame. */
+
+    return p-1;
+}
+
+int cobs_encode(char *dst, char *src, size_t srclen) {
+    if (srclen > 254)
+        return -1;
+
+    size_t p = 0;
+    while (p <= srclen) {
+
+        char val;
+        if (p != 0 && src[p-1] != 0) {
+            val = src[p-1];
+
+        } else {
+            size_t q = p;
+            while (q < srclen && src[q] != 0)
+                q++;
+            val = (char)q-p+1;
+        }
+
+
+    *dst++ = val;
+        p++;
+    }
+
+    *dst++ = 0;
+
+    return 0;
+}
+ 
+void print_usage(char *prog) {
+    fprintf(stderr, "Usage: %s [-p /dev/serial/some_port] [-b baudrate] dbfile.sqilte3\n", prog);
+}
+
+void hexdump(const void* data, size_t size) {
+	char ascii[17];
+	size_t i, j;
+	ascii[16] = '\0';
+	for (i = 0; i < size; ++i) {
+		printf("%02X ", ((unsigned char*)data)[i]);
+		if (((unsigned char*)data)[i] >= ' ' && ((unsigned char*)data)[i] <= '~') {
+			ascii[i % 16] = ((unsigned char*)data)[i];
+		} else {
+			ascii[i % 16] = '.';
+		}
+		if ((i+1) % 8 == 0 || i+1 == size) {
+			printf(" ");
+			if ((i+1) % 16 == 0) {
+				printf("|  %s \n", ascii);
+			} else if (i+1 == size) {
+				ascii[(i+1) % 16] = '\0';
+				if ((i+1) % 16 <= 8) {
+					printf(" ");
+				}
+				for (j = (i+1) % 16; j < 16; ++j) {
+					printf("   ");
+				}
+				printf("|  %s \n", ascii);
+			}
+		}
+	}
+}
+
+int main(int argc, char *argv[]) {
+    
+    int opt;
+    int baudrate = 250000;
+    char *endptr = NULL;
+    char *port = NULL;
+    char *dbfile = NULL;
+    while ((opt = getopt(argc, argv, "p:b:")) != -1) {
+        switch (opt) {
+            case 'p':
+                port = optarg;
+                break;
+            case 'b':
+                baudrate = strtol(optarg, &endptr, 10);
+                if (errno == ERANGE || endptr == NULL || *endptr != '\0') {
+                    fprintf(stderr, "Invalid baudrate \"%s\"\n", optarg);
+                    print_usage(argv[0]);
+                }
+                break;
+            default:
+                print_usage(argv[0]);
+                exit(EXIT_FAILURE);
+        }
+    }
+
+    if (port == NULL) {
+        DIR *le_dir = opendir("/dev/serial/by-id");
+        if (le_dir == NULL) {
+            fprintf(stderr, "No serial port given and could not find any in /dev/serial\n");
+            exit(EXIT_FAILURE);
+
+        }
+
+        struct dirent *de;
+        while ((de = readdir(le_dir))) {
+            if (de == NULL) {
+                fprintf(stderr, "No serial port given and could not find any in /dev/serial\n");
+                exit(EXIT_FAILURE);
+            }
+
+            if (!strncmp(de->d_name, ".", sizeof(de->d_name)) ||
+                !strncmp(de->d_name, "..", sizeof(de->d_name)))
+                continue;
+
+            if (port != NULL) {
+                fprintf(stderr, "No serial port given and found multiple candidates in /dev/serial\n");
+                exit(EXIT_FAILURE);
+            }
+
+            const char *prefix = "/dev/serial/by-id/";
+            port = malloc(strlen(prefix) + sizeof(de->d_name) + 1);
+            if (port == NULL) {
+                fprintf(stderr, "Could not allocate memory\n");
+                exit(EXIT_FAILURE);
+            }
+            strcpy(port, prefix);
+            strncat(port, de->d_name, sizeof(de->d_name));
+        }
+        fprintf(stderr, "No port given, defaulting to %s\n", port);
+        closedir(le_dir);
+    }
+
+    if (optind != argc - 1) {
+        fprintf(stderr, "Too few arguments\n");
+        print_usage(argv[0]);
+        exit(EXIT_FAILURE);
+    }
+
+    dbfile = argv[optind];
+    printf("Using database file %s\n", dbfile);
+    fflush(stdout);
+
+    int fd = open(port, O_RDWR|O_NOCTTY|O_SYNC);
+    if (fd < 0) {
+        fprintf(stderr, "Cannot open serial port: %s\n", strerror(errno));
+        exit(EXIT_FAILURE);
+    }
+
+    if (set_interface_attribs (fd, baudrate))
+        exit(EXIT_FAILURE);
+
+    sqlite3 *db;
+    if (sqlite3_open(dbfile, &db) != SQLITE_OK) {
+        fprintf(stderr, "Cannot open database: %s\n", sqlite3_errmsg(db));
+        sqlite3_close(db);
+        exit(EXIT_FAILURE);
+    }
+
+    char *errmsg;
+    if (sqlite3_exec(db,
+                "CREATE TABLE IF NOT EXISTS measurements (rx_time INTEGER, tx_seq INTEGER, rx_seq INTEGER, data BLOB);",
+                NULL, NULL, &errmsg) != SQLITE_OK) {
+        fprintf(stderr, "Error initializing databse: %s\n", errmsg);
+        sqlite3_close(db);
+        exit(EXIT_FAILURE);
+    }
+
+    const char *insert_sql = "INSERT INTO measurements VALUES (?, ?, ?, ?)";
+    sqlite3_stmt *insert_stmt;
+    if (sqlite3_prepare_v2(db, insert_sql, strlen(insert_sql), &insert_stmt, NULL) != SQLITE_OK) {
+        fprintf(stderr, "Error compiling SQL: %s\n", sqlite3_errmsg(db));
+        sqlite3_close(db);
+        exit(EXIT_FAILURE);
+    }
+
+    char buf [1024];
+    int in_sync = 0, wpos = 0;
+    struct __attribute__((__packed__)) {
+        uint32_t crc;
+        uint8_t pid;
+        uint8_t _pad;
+        uint16_t seq;
+        uint16_t data[32];
+    } packet;
+    struct __attribute__((__packed__)) {
+        uint8_t type;
+        uint8_t pid;
+    } wpacket;
+    char wbuf[4];
+
+    int epollfd = epoll_create1(0);
+    if (epollfd < 0)
+        goto epoll_err;
+
+    #define MAX_EVENTS 10
+    struct epoll_event ev, events[MAX_EVENTS];
+    ev.events = EPOLLIN;
+    ev.data.fd = fd;
+    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) < 0)
+        goto epoll_err;
+
+    wpacket.type = 1;
+    wpacket.pid = 0;
+    cobs_encode(wbuf, (char *)&wpacket, sizeof(wpacket));
+    write(fd, wbuf, sizeof(wbuf));
+
+    /* FIXME begin debug code */
+    for (int i=0; i<32; i++) {
+        wpacket.type = 2;
+        wpacket.pid = packet.pid;
+        cobs_encode(wbuf, (char *)&wpacket, sizeof(wpacket));
+        write(fd, wbuf, sizeof(wbuf));
+        usleep(20);
+    }
+    /* FIXME end debug code */
+
+    int current_seq = -1;
+    uint64_t local_seq = 0;
+    while (23) {
+        int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
+        if (nfds == -1)
+            goto epoll_err;
+
+        if (nfds == 0)
+            continue;
+
+        ssize_t n = read(fd, buf+wpos, sizeof(buf)-wpos);
+        printf("--- read wpos=%d n=%ld\n", wpos, n);
+        hexdump(buf+wpos, n);
+        if (n<0) {
+            if (errno == EAGAIN || errno == EINTR)
+                continue;
+
+            fprintf(stderr, "Error reading from port: %s\n", strerror(errno));
+            goto loop_err;
+        }
+        //printf("--- debug: read n=%d bytes at wpos=%d\n", n, wpos);
+        //fflush(stdout);
+        wpos += n;
+
+        while (23) {
+            void *first_nul = memchr(buf, 0, wpos) ;
+            ssize_t first_nul_offx = first_nul - (void*)buf;
+            ssize_t remaining = wpos - first_nul_offx;
+
+            if (!in_sync) {
+                if (first_nul) {
+                    memmove(buf, first_nul+1, remaining-1);
+                    wpos = remaining-1;
+                    in_sync = 1;
+                    continue;
+
+                } else {
+                    wpos = 0;
+                    break;
+                }
+            }
+
+            if (!first_nul)
+                break;
+
+            printf("--- debug: first_nul=%p (idx=%ld) wpos=%d remaining=%ld\n", first_nul, first_nul_offx, wpos, remaining);
+            hexdump(buf, 80);
+
+            int rc = cobs_decode((char *)&packet, sizeof(packet), buf, wpos);
+            if (rc < 0) {
+                printf("Framing error: rc=%d\n", rc);
+                goto it_err;
+            }
+            
+            /* Use zlib to calculate CRC32. The STM32 code calculates the CRC byte-wise, so we emulate this here. */
+            uint32_t our_crc = 0;
+            if (rc > 0) {
+                uint8_t buf[4] = {0};
+                for (int i=4; i<rc; i++) {
+                    buf[3] = ((uint8_t *)&packet)[i];
+                    our_crc = crc32(our_crc, buf, sizeof(buf));
+                }
+            }
+
+            bool error = false;
+            /* Check CRC */
+            if (our_crc != packet.crc) {
+                printf("CRC mismatch: seq=%d packet=%08x computed=%08x\n", packet.pid, packet.crc, our_crc);
+                error = true;
+            }
+
+            /* Check device sequence number */
+            int last_seq = current_seq;
+            int predicted_seq = (last_seq+1) % 0xffff;
+            if (!error)
+                current_seq = packet.seq;
+            if (last_seq >= 0 && packet.seq != predicted_seq) {
+                printf("SEQ mismatch: packet=%d computed=%d\n", packet.seq, predicted_seq);
+                error = true;
+            }
+
+            if (error)
+                goto it_err;
+
+            /* Write to database */
+            struct timespec ts;
+            if (clock_gettime(CLOCK_REALTIME, &ts)) {
+                fprintf(stderr, "Error getting current wall-clock time: %s\n", strerror(errno));
+                goto loop_err;
+            }
+            uint64_t timestamp = ts.tv_sec*1000 + ts.tv_nsec/1000000;
+
+            if (sqlite3_bind_int(insert_stmt, 1, timestamp) != SQLITE_OK)
+                goto write_err;
+            
+            if (sqlite3_bind_int(insert_stmt, 2, packet.seq) != SQLITE_OK)
+                goto write_err;
+
+            if (sqlite3_bind_int(insert_stmt, 3, local_seq) != SQLITE_OK)
+                goto write_err;
+
+            if (sqlite3_bind_blob(insert_stmt, 4, packet.data, sizeof(packet.data), SQLITE_STATIC) != SQLITE_OK)
+                goto write_err;
+
+            while ((rc = sqlite3_step(insert_stmt)) == SQLITE_BUSY)
+                ;
+            if (rc != SQLITE_DONE)
+                goto write_err;
+
+            if (sqlite3_reset(insert_stmt) != SQLITE_OK)
+                goto write_err;
+
+            if (sqlite3_clear_bindings(insert_stmt) != SQLITE_OK)
+                goto write_err;
+
+            local_seq++;
+
+            printf("OK: seq=%d crc=%08x\n", current_seq, packet.crc);
+
+            /* send ACK reply */
+            wpacket.type = 2;
+            wpacket.pid = packet.pid;
+            cobs_encode(wbuf, (char *)&wpacket, sizeof(wpacket));
+            write(fd, wbuf, sizeof(wbuf));
+
+it_err:
+            /* Fixup buffer for next iteration */
+            if (remaining-1 > 0) {
+                printf(" ---memmove(buf=%p, first_nul+1=%p, remaining-1=%ld);-->\n", buf, first_nul+1, remaining-1);
+                memmove(buf, first_nul+1, remaining-1);
+            }
+            //hexdump(buf, 80);
+            fflush(stdout);
+            printf("--- continuing wpos=%d->%d\n", wpos, (int)(remaining-1));
+            wpos = remaining-1;
+        }
+    }
+
+    return 0;
+
+write_err:
+    fprintf(stderr, "Error writing to database: %s\n", sqlite3_errmsg(db));
+    sqlite3_close(db);
+    return EXIT_FAILURE;
+
+epoll_err:
+    fprintf(stderr, "epoll error: %s\n", strerror(errno));
+
+loop_err:
+    sqlite3_close(db);
+    return EXIT_FAILURE;
+}
diff --git a/hardware/fw/tw_test.py b/hardware/fw/tw_test.py
new file mode 100644
index 0000000..e329abd
--- /dev/null
+++ b/hardware/fw/tw_test.py
@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+
+import os
+from time import time
+from binascii import hexlify
+import enum
+import struct
+import zlib
+import sys
+import sqlite3
+
+import serial
+from cobs import cobs
+
+
+class CtrlPacketTypes(enum.Enum):
+    RESET = 1
+    ACK = 2
+    RETRANSMIT = 3
+
+def unpack_head(fmt, data):
+    split = struct.calcsize(fmt)
+    return [ *struct.unpack(fmt, data[:split]), data[split:] ]
+
+def ctrl_packet(ptype, pid=0):
+    return cobs.encode(struct.pack('BB', ptype.value, pid)) + b'\0'
+
+ctrl_reset = lambda: ctrl_packet(CtrlPacketTypes.RESET)
+ctrl_ack = lambda pid: ctrl_packet(CtrlPacketTypes.ACK, pid)
+ctrl_retransmit = lambda pid: ctrl_packet(CtrlPacketTypes.RETRANSMIT, pid)
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('-b', '--baudrate', type=int, default=250000)
+    parser.add_argument('port', nargs='?', default=None)
+    parser.add_argument('dbfile')
+    args = parser.parse_args()
+
+    if args.port is None:
+        try:
+            candidate, = os.listdir('/dev/serial/by-id')
+            args.port = os.path.join('/dev/serial/by-id', candidate)
+            print(f'No port given, guessing {args.port}')
+
+        except:
+            print('No port given and could not guess port. Exiting.')
+            sys.exit(1)
+    
+    ser = serial.Serial(args.port, args.baudrate, timeout=1.0)
+    db = sqlite3.connect(args.dbfile)
+    db.execute('CREATE TABLE IF NOT EXISTS measurements (run_id INTEGER, rx_ts INTEGER, seq INTEGER, data BLOB)')
+    db.execute('''CREATE TABLE IF NOT EXISTS errors (
+                run_id INTEGER,
+                rx_ts INTEGER,
+                type TEXT,
+                seq INTEGER,
+                pid INTEGER,
+                pid_expected INTEGER,
+                crc32 INTEGER,
+                crc32_expected INTEGER,
+                data BLOB)''')
+    run_id, = db.execute('SELECT IFNULL(MAX(run_id), -1) + 1 FROM measurements').fetchone()
+
+    ser.flushInput()
+    ser.write(ctrl_reset())
+    ser.flushOutput()
+
+    last_pid = None
+    lines_written = 0
+    cur = db.cursor()
+    capture_start = time()
+    while True:
+        #ser.write(cobs.encode(b'\x01\xff') + b'\0')
+        data = ser.read_until(b'\0')
+        for data in data.split(b'\0')[:-1]: # data always ends on \0 due to read_until, so split off the trailing empty bytes()
+            try:
+                if not data:
+                    #print(f'{time():>7.3f} Timeout: resetting')
+                    #ser.write(cobs.encode(b'\x01\xff') + b'\0') # reset
+                    ser.write(ctrl_ack(0)) # FIXME delet this
+                    cur.execute('INSERT INTO errors(run_id, rx_ts, type) VALUES (?, ?, "retransmission")',
+                            (run_id, int(time()*1000)))
+                    continue
+
+                crc32, payload = unpack_head('I', cobs.decode(data))
+                pid, seq, data = unpack_head('xBH', payload)
+                ts = time()
+
+                # Calculate byte-wise CRC32
+                our_crc = zlib.crc32(bytes(b for x in payload for b in (0, 0, 0, x)))
+                #log.append((time(), seq, crc32, our_crc, pid, data))
+                bars = '\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588'
+                sparkline = ''.join(bars[int(x/4096*8)] for x in struct.unpack('<32H', data))
+                print(f'\033[38;5;249m{ts-capture_start:>10.3f}',
+                        f'\033[94m{seq:05d}',
+                        f'\033[38;5;243m{crc32:08x}',
+                        f'\033[38;5;243m{our_crc:08x}',
+                        f'\033[38;5;243m{pid}',
+                        f'\033[0m{hexlify(data).decode()}',
+                        f'\033[94m{sparkline}\033[0m', end='')
+
+                error = False
+                suppress_ack = False
+                if crc32 != our_crc:
+                    print(' \033[1;91mCRC ERROR\033[0m', end='')
+                    suppress_ack = True
+                    error = True
+
+                if last_pid is not None and pid != (last_pid+1)%8:
+                    print(' \033[1;93mPID ERROR\033[0m', end='')
+                    error = True
+                else:
+                    last_pid = pid
+
+                if not suppress_ack:
+                    ser.write(ctrl_ack(pid))
+                    ser.flushOutput()
+
+                if not suppress_ack:
+                    cur.execute('INSERT INTO measurements VALUES (?, ?, ?, ?)', (run_id, int(ts*1000), seq, data))
+                if error:
+                    cur.execute('INSERT INTO errors VALUES (?, ?, "pid", ?, ?, ?, ?, ?, ?)',
+                            (run_id, int(ts*1000), seq, pid, (last_pid+1)%8, crc32, our_crc, data))
+
+                print()
+                lines_written += 1
+                if lines_written == 80:
+                    lines_written = 0
+                    print('\033[2J\033[H', end='')
+                    delta = ts-capture_start
+                    print(f'\033[7mRun {run_id}, capturing for {delta//3600//24:> 3.0f}:{delta//3600%24:02.0f}:{delta//60%60:02.0f}:{delta%60:06.3f}\033[0m')
+                    db.commit()
+
+            except Exception as e:
+                print(e, len(data))
+                ser.write(ctrl_ack(0)) # FIXME delet this
+