host: add bladerf_adf4002_{get,set}_refclk and related functionality (#15)

* host: libbladeRF: add functions to get/set ADF4002 refclk frequency

* host: bladeRF-cli: add print/set adf_refclk

* host: python: add adf4002_refclk functions

This permits getting and setting the ADF4002 reference clock
frequency.

>>> import bladerf
>>> b = bladerf.BladeRF()
ad9361_init : AD936x Rev 2 successfully initialized
>>> b.adf4002_refclk
10000000
>>> b.adf4002_refclk = 9000000
>>> b.adf4002_refclk
9000000
>>> b.adf4002_refclk = 900000000
[ERROR @
"/home/rtucker/dev/privatebladeRF/host/libraries/libbladeRF/src/board/bladerf2/bladerf2.c":4360]
bladerf_adf4002_set_refclk: bladerf_adf4002_calculate_ratio failed:
Provided parameter was out of the allowable range
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File
"/home/rtucker/dev/privatebladeRF/host/libraries/libbladeRF_bindings/python/bladerf.py",
line 1581, in set_adf4002_refclk
    _check_error(ret)
  File
"/home/rtucker/dev/privatebladeRF/host/libraries/libbladeRF_bindings/python/bladerf.py",
line 998, in _check_error
    raise globals()[errorval.name](err)
bladerf.RangeError: Provided parameter was out of the allowable range
>>> b.adf4002_refclk
9000000
>>> b.adf4002_refclk = 10000000
>>> b.adf4002_refclk
10000000

* host: libbladeRF: make ADF convenience functions static

bladerf_adf4002_set_refclk is much nicer (and safer) than calculating
the R/N ratio and then doing a bladerf_adf4002_configure.

* host: python: update cffi header block
This commit is contained in:
Rey Tucker 2018-03-23 11:10:14 -04:00 • committed by GitHub
commit 10d0f549b2
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 328 additions and 158 deletions

View file

@ -87,6 +87,11 @@ def _print_cmd_info(device=None, devinfo=None, verbose=False):
print(" Modes ", _strify_list(b.loopback_modes))
print("RX Mux ", b.rx_mux)
print("ADF4002 Mode ", _bool_to_onoff(b.adf4002_enable))
if b.adf4002_enable:
print("ADF4002 Refclk ", b.adf4002_refclk)
print("ADF4002 Locked ", _bool_to_onoff(b.adf4002_locked))
print("RX Channel Count ", b.rx_channel_count)
for c in range(b.rx_channel_count):
ch = b.Channel(bladerf.CHANNEL_RX(c))

View file

@ -585,10 +585,12 @@ ffi.cdef("""
int bladerf_adf4002_get_locked(struct bladerf *dev, bool *locked);
int bladerf_adf4002_get_enable(struct bladerf *dev, bool *enabled);
int bladerf_adf4002_set_enable(struct bladerf *dev, bool enable);
int bladerf_adf4002_configure(struct bladerf *dev, uint16_t R,
uint16_t N);
int bladerf_adf4002_calculate_ratio(uint64_t ref_freq, uint64_t
clock_freq, uint16_t *R, uint16_t *N);
int bladerf_adf4002_get_refclk_range(struct bladerf *dev, struct
bladerf_range *range);
int bladerf_adf4002_get_refclk(struct bladerf *dev, uint64_t
*frequency);
int bladerf_adf4002_set_refclk(struct bladerf *dev, uint64_t
frequency);
int bladerf_adf4002_read(struct bladerf *dev, uint8_t address,
uint32_t *val);
int bladerf_adf4002_write(struct bladerf *dev, uint8_t address,
@ -1534,19 +1536,25 @@ class BladeRF:
# ADF4002 Phase Detector/Frequency Synthesizer
def get_adf4002_locked(self):
locked = ffi.new("bool *")
ret = libbladeRF.bladerf_adf4002_get_locked(self.dev[0], locked)
_check_error(ret)
return bool(locked[0])
try:
locked = ffi.new("bool *")
ret = libbladeRF.bladerf_adf4002_get_locked(self.dev[0], locked)
_check_error(ret)
return bool(locked[0])
except UnsupportedError:
return None
adf4002_locked = property(get_adf4002_locked,
doc="ADF4002 PLL lock indication")
def get_adf4002_enable(self):
enable = ffi.new("bool *")
ret = libbladeRF.bladerf_adf4002_get_enable(self.dev[0], enable)
_check_error(ret)
return bool(enable[0])
try:
enable = ffi.new("bool *")
ret = libbladeRF.bladerf_adf4002_get_enable(self.dev[0], enable)
_check_error(ret)
return bool(enable[0])
except UnsupportedError:
return None
def set_adf4002_enable(self, enable):
ret = libbladeRF.bladerf_adf4002_set_enable(self.dev[0], enable)
@ -1555,20 +1563,21 @@ class BladeRF:
adf4002_enable = property(get_adf4002_enable, set_adf4002_enable,
doc="ADF4002 Enable")
def set_adf4002_frequency(self, refclk, sysclk=BLADERF_VCTCXO_FREQUENCY):
r = ffi.new("uint16_t *")
n = ffi.new("uint16_t *")
# Calculate R and N values for clock ratio
ret = libbladeRF.bladerf_adf4002_calculate_ratio(int(refclk),
int(sysclk), r, n)
def get_adf4002_refclk(self):
try:
freq = ffi.new("uint64_t *")
ret = libbladeRF.bladerf_adf4002_get_refclk(self.dev[0], freq)
_check_error(ret)
return int(freq[0])
except UnsupportedError:
return None
def set_adf4002_refclk(self, freq):
ret = libbladeRF.bladerf_adf4002_set_refclk(self.dev[0], freq)
_check_error(ret)
# Configure w/ the ratios
ret = libbladeRF.bladerf_adf4002_configure(self.dev[0], r[0], n[0])
_check_error(ret)
adf4002_frequency = property(fset=set_adf4002_frequency,
doc="ADF4002 Reference Clock frequency")
adf4002_refclk = property(get_adf4002_refclk, set_adf4002_refclk,
doc="ADF4002 Reference Clock frequency")
# Power source