TIM3 working stably now

4 files changed, 872 insertions, 35 deletions

diff --git a/driver_fw/main.c b/driver_fw/main.c
index 324ca11..730065c 100644
--- a/driver_fw/main.c
+++ b/driver_fw/main.c
@@ -70,7 +70,7 @@ int main(void) {
     TIM1->BDTR = TIM_BDTR_MOE | (0xc0 | (63-32))<<TIM_BDTR_DTG_Pos; /* Enable MOE on next update event, i.e. on initial timer load.
                                                           Set dead-time to 100us. */
     TIM1->CR1 |= TIM_CR1_CEN;
-    TIM1->ARR = 1000-1; /* Set f=1.0kHz/T=1.0ms */
+    TIM1->ARR = 400-1; /* Set f=2.5kHz/T=0.4ms */
 
     xfr_8b10b_encode_reset(&txstate.st);
     txstate.current_symbol = txstate.next_symbol = xfr_8b10b_encode(&txstate.st, K28_1) | 1<<10;
diff --git a/fw/Scope.ipynb b/fw/Scope.ipynb
index b7ac077..9222f06 100644
--- a/fw/Scope.ipynb
+++ b/fw/Scope.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 55,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -835,6 +835,824 @@
     "    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": 74,
+   "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=\"640\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "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": {
diff --git a/fw/adc.c b/fw/adc.c
index 3a86e05..eb5d4b5 100644
--- a/fw/adc.c
+++ b/fw/adc.c
@@ -180,9 +180,12 @@ void receive_bit(struct bit_detector_st *st, int bit) {
         st->sync = 0;
         /* Fall through so we also pass the error to receive_symbol */
 
+    GPIOA->BSRR = 1<<9;
     receive_symbol(&st->rx_st, symbol);
+    GPIOA->BRR = 1<<9;
 
     /* Debug scope logic */
+    /*
     static int debug_buf_pos = 0;
     if (st->sync) {
         if (debug_buf_pos < NCH) {
@@ -199,6 +202,7 @@ void receive_bit(struct bit_detector_st *st, int bit) {
             }
         }
     }
+    */
 }
 
 void bit_detector(struct bit_detector_st *st, int a) {
@@ -216,7 +220,6 @@ void bit_detector(struct bit_detector_st *st, int a) {
         st->last_bit = new_bit;
         st->len_ctr = 0;
         st->committed_len_ctr = st->base_interval_cycles>>1;
-        unblank(new_bit);
 
     } else if (st->len_ctr >= st->committed_len_ctr) {
         st->committed_len_ctr += st->base_interval_cycles;
@@ -225,8 +228,9 @@ void bit_detector(struct bit_detector_st *st, int a) {
 }
 
 void DMA1_Channel1_IRQHandler(void) {
+    GPIOA->BSRR = 1<<5;
     /* ISR timing measurement for debugging */
-    int start = SysTick->VAL;
+    //int start = SysTick->VAL;
 
     /* Clear the interrupt flag */
     DMA1->IFCR |= DMA_IFCR_CGIF1;
@@ -255,10 +259,13 @@ void DMA1_Channel1_IRQHandler(void) {
     bit_detector((struct bit_detector_st *)&st.det_st, a);
 
     /* ISR timing measurement for debugging */
+    /*
     int end = SysTick->VAL;
     int tdiff = start - end;
     if (tdiff < 0)
         tdiff += SysTick->LOAD;
     st.dma_isr_duration = tdiff;
+    */
+    GPIOA->BRR = 1<<5;
 }
 
diff --git a/fw/main.c b/fw/main.c
index ded4643..8a89157 100644
--- a/fw/main.c
+++ b/fw/main.c
@@ -71,40 +71,28 @@ void blank(void) {
     set_drv_gpios(0);
 }
 
-int bit; /* FIXME */
+volatile int bit; /* FIXME */
+void unblank_low(void) {
+    if (bit)
+        set_drv_gpios(out_state & 0xf);
+    else
+        set_drv_gpios(out_state >> 4);
+}
+
 void unblank(int new_bit) {
     bit = new_bit;
-    NVIC_EnableIRQ(TIM3_IRQn);
-    NVIC_SetPriority(TIM3_IRQn, 3<<5);
-
-    TIM3->DIER &= (~TIM_DIER_UIE) & (~TIM_DIER_CC4IE);
-
-    TIM3->CCMR2 = (6<<TIM_CCMR2_OC4M_Pos); /* PWM Mode 1 to get a clean trigger signal */
-    TIM3->CCER  = TIM_CCER_CC4E; /* Enable capture/compare unit 4 connected to ADC */
-
-    TIM3->CCR4  = 50; /* Trigger towards start of timer cycle */
-    TIM3->PSC   = 48-1;
-    TIM3->ARR   = 400-1;
-
-    TIM3->EGR  |= TIM_EGR_UG;
-    TIM3->CR1   = TIM_CR1_ARPE | TIM_CR1_OPM;
-    TIM3->SR &= (~TIM_SR_UIF) & (~TIM_SR_CC4IF);
-    TIM3->DIER |= TIM_DIER_UIE | TIM_DIER_CC4IE;
-
-    TIM3->CR1  |= TIM_CR1_CEN;
+    unblank_low();
 }
 
 void TIM3_IRQHandler(void) {
-    if (TIM3->SR & TIM_SR_UIF) {
+    GPIOA->BSRR = 1<<10;
+    if (TIM3->SR & TIM_SR_UIF)
+        unblank_low();
+    else
         blank();
-    } else {
-        if (bit)
-            set_drv_gpios(out_state & 0xf);
-        else
-            set_drv_gpios(out_state >> 4);
-    }
 
     TIM3->SR = 0;
+    GPIOA->BRR = 1<<10;
 }
 
 void handle_command(int command, uint8_t *args) {
@@ -133,24 +121,38 @@ int main(void) {
     while (!(RCC->CR&RCC_CR_PLLRDY));
     RCC->CFGR |= (2<<RCC_CFGR_SW_Pos);
     SystemCoreClockUpdate();
-    SysTick_Config(SystemCoreClock/1000); /* 1ms interval */
+    //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;
 
+    /* TIM3 foo */
+    TIM3->CCMR2 = (6<<TIM_CCMR2_OC4M_Pos); /* PWM Mode 1 to get a clean trigger signal */
+    TIM3->CCER  = TIM_CCER_CC4E; /* Enable capture/compare unit 4 connected to ADC */
+
+    TIM3->PSC   =  48-1;
+    TIM3->CCR4  = 170-1;
+    TIM3->ARR   = 200-1;
+
+    TIM3->DIER |= TIM_DIER_UIE | TIM_DIER_CC4IE;
+
+    TIM3->CR1  |= TIM_CR1_CEN;
+    NVIC_EnableIRQ(TIM3_IRQn);
+    NVIC_SetPriority(TIM3_IRQn, 3<<5);
+
     GPIOA->MODER |=
           (0<<GPIO_MODER_MODER0_Pos)  /* PA0  - Vmeas_A to ADC */
         | (0<<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_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 */
+        | (1<<GPIO_MODER_MODER9_Pos)  /* PA9  - TP2 */
+        | (1<<GPIO_MODER_MODER10_Pos);/* PA10 - TP3 */
 
     /* Set shift register IO GPIO output speed */
     GPIOA->OSPEEDR |=
@@ -162,14 +164,22 @@ int main(void) {
 
     set_drv_gpios(0);
 
-	adc_configure_monitor_mode(&cmd_if.cmd_if, 50 /*us*/);
+	adc_configure_monitor_mode(&cmd_if.cmd_if, 20 /*us*/);
 
+    int old = 0;
     while (42) {
+        int new = GPIOA->IDR & (1<<0);
+        if (new != old) {
+            unblank(new);
+            TIM3->EGR  |= TIM_EGR_UG;
+            old = new;
+        }
         /* idle */
     }
 }
 
 void NMI_Handler(void) {
+    asm volatile ("bkpt");
 }
 
 void HardFault_Handler(void) __attribute__((naked));
@@ -178,10 +188,12 @@ void HardFault_Handler() {
 }
 
 void SVC_Handler(void) {
+    asm volatile ("bkpt");
 }
 
 
 void PendSV_Handler(void) {
+    asm volatile ("bkpt");
 }
 
 void SysTick_Handler(void) {