tree be7b53c67e18019e7619a7288bca3033580fcb6e
parent 980525c8a9cc620314aa36e566d30e0592f280d5
author Tom Tsou <tom.tsou@ettus.com> 1496539908 -0700
committer Tom Tsou <tom.tsou@ettus.com> 1497460504 -0700

siggen: Add osmo-siggen for GSM/EDGE test signal generation

* Adds 4 and 1 pulse Laurent GMSK modulators
* Adds NCO based modulator
* Adds synchronization and frequency burst generators
* Adds GPIO frame trigger on GPIO-0
* Tested on USRP B210 only
* Requires C++14 support

B210 GPIO Pin Map

             J504
           ---------
fp_gpio<0> | 1 | 2 | fp_gpio<1>
           ---------
fp_gpio<2> | 3 | 4 | fp_gpio<3>
           ---------
fp_gpio<4> | 5 | 6 | fp_gpio<5>
           ---------
fp_gpio<6> | 7 | 8 | fp_gpio<7>
           ---------
       gnd | 9 | 10| gnd
           ---------

Change-Id: I891725d7f0cfa97c79e64f978a60dc11a206195c
Signed-off-by: Tom Tsou <tom.tsou@ettus.com>
