New LF edge detection algorithm + lowpass filter

This is a new LF edge detection algorithm for the FPGA.

- It uses a low-pass IIR filter to clean the signal
(see https://fail0verflow.com/blog/2014/proxmark3-fpga-iir-filter.html)
- The algorithm is able to detect consecutive peaks in the same
  direction
- It uses an envelope follower to dynamically adjust the peak thresholds
- The main threshold used in the envelope follower can be set from the ARM side

fpga/lf_edge_detect.v,
fpga/lp20khz_1MSa_iir_filter.v,
fpga/min_max_tracker.v: New file.

fpga/lo_edge_detect.v, fpga/fpga_lf.v: Modify accordingly.

armsrc/apps.h (FPGA_CMD_SET_USER_BYTE1,
FPGA_CMD_SET_EDGE_DETECT_THRESHOLD): New FPGA command.
fpga/fpga_lf.v: Modify accordingly/Add a 8bit user register.

fpga/fpga_lf.bit: Update accordingly.

fpga/tests: New directory for testbenches

fpga/tests/Makefile: New file. It compiles the testbenches
and runs all the tests by default (comparing with the golden output)

fpga/tests/tb_lp20khz_1MSa_iir_filter.v,
fpga/tests/tb_min_max_tracker.v,
fpga/tests/tb_lf_edge_detect.v: New testbenches

fpga/tests/plot_edgedetect.py: New script to plot the results from
the edge detection tests.

fpga/tests/tb_data: New directory for data and golden outputs

fpga/tests/plot_edgedetect.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+#-----------------------------------------------------------------------------
+# Copyright (C) 2014 iZsh <izsh at fail0verflow.com>
+#
+# This code is licensed to you under the terms of the GNU GPL, version 2 or,
+# at your option, any later version. See the LICENSE.txt file for the text of
+# the license.
+#-----------------------------------------------------------------------------
+import numpy
+import matplotlib.pyplot as plt
+import sys
+
+if len(sys.argv) != 2:
+	print "Usage: %s <basename>" % sys.argv[0]
+	sys.exit(1)
+
+BASENAME = sys.argv[1]
+
+nx = numpy.fromfile(BASENAME + ".time")
+
+def plot_time(dat1):
+    plt.plot(nx, dat1)
+
+sig = open(BASENAME + ".filtered").read()
+sig = map(lambda x: ord(x), sig)
+
+min_vals = open(BASENAME + ".min").read()
+min_vals = map(lambda x: ord(x), min_vals)
+
+max_vals = open(BASENAME + ".max").read()
+max_vals = map(lambda x: ord(x), max_vals)
+
+states = open(BASENAME + ".state").read()
+states = map(lambda x: ord(x) * 10 + 65, states)
+
+toggles = open(BASENAME+ ".toggle").read()
+toggles = map(lambda x: ord(x) * 10 + 80, toggles)
+
+high = open(BASENAME + ".high").read()
+high = map(lambda x: ord(x), high)
+highz = open(BASENAME + ".highz").read()
+highz = map(lambda x: ord(x), highz)
+lowz = open(BASENAME + ".lowz").read()
+lowz = map(lambda x: ord(x), lowz)
+low = open(BASENAME + ".low").read()
+low = map(lambda x: ord(x), low)
+
+plot_time(sig)
+plot_time(min_vals)
+plot_time(max_vals)
+plot_time(states)
+plot_time(toggles)
+plot_time(high)
+plot_time(highz)
+plot_time(lowz)
+plot_time(low)
+
+plt.show()