Mirrors
/
go-bladerf
mirror of https://github.com/erayarslan/go-bladerf
7
0
Fork 1
Code Issues Releases Wiki Activity

hakuna matata

This commit is contained in:
Eray Arslan 2021-05-21 21:47:02 +03:00
parent 19e8f3c331
commit 1ed25e669c
5 changed files with 337 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@ -13,6 +13,7 @@
## Notes
```shell
brew install pkg-config
brew install portaudio
export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/Cellar/portaudio/19.6.0/lib/pkgconfig"
```

295
bladerf.go
View File

@ -27,15 +27,17 @@ func StreamCallback(
metadata *C.struct_bladerf_metadata,
samples unsafe.Pointer,
numSamples C.size_t,
userData unsafe.Pointer,
userDataPtr unsafe.Pointer,
) unsafe.Pointer {
ud := pointer.Restore(userData).(UserData)
userData := pointer.Restore(userDataPtr).(UserData)
for i := uint32(0); i < uint32(numSamples); i++ {
ud.results[i] = int16(*((*C.int16_t)(unsafe.Pointer(uintptr(samples) + (C.sizeof_int16_t * uintptr(i))))))
userData.results[i] = int16(
*((*C.int16_t)(unsafe.Pointer(uintptr(samples) + (C.sizeof_int16_t * uintptr(i))))),
)
}
ud.callback(ud.results)
userData.callback(userData.results)
return samples
}
@ -45,17 +47,17 @@ func GetVersion() Version {
return NewVersion(&version)
}
func PrintVersion(version Version) {
func (version *Version) Print() {
fmt.Printf("v%d.%d.%d (\"%s\")", version.major, version.minor, version.patch, version.describe)
}
func LoadFpga(bladeRF BladeRF, imagePath string) error {
func (bladeRF *BladeRF) LoadFpga(imagePath string) error {
path := C.CString(imagePath)
defer C.free(unsafe.Pointer(path))
return GetError(C.bladerf_load_fpga(bladeRF.ref, path))
}
func GetFpgaSize(bladeRF BladeRF) (FpgaSize, error) {
func (bladeRF *BladeRF) GetFpgaSize() (FpgaSize, error) {
var size C.bladerf_fpga_size
err := GetError(C.bladerf_get_fpga_size(bladeRF.ref, &size))
@ -66,7 +68,7 @@ func GetFpgaSize(bladeRF BladeRF) (FpgaSize, error) {
return FpgaSize(size), nil
}
func GetQuickTune(bladeRF BladeRF, channel Channel) (QuickTune, error) {
func (bladeRF *BladeRF) GetQuickTune(channel Channel) (QuickTune, error) {
var quickTune C.struct_bladerf_quick_tune
err := GetError(C.bladerf_get_quick_tune(bladeRF.ref, C.bladerf_channel(channel), &quickTune))
@ -78,11 +80,11 @@ func GetQuickTune(bladeRF BladeRF, channel Channel) (QuickTune, error) {
return QuickTune{ref: &quickTune}, nil
}
func CancelScheduledReTunes(bladeRF BladeRF, channel Channel) error {
func (bladeRF *BladeRF) CancelScheduledReTunes(channel Channel) error {
return GetError(C.bladerf_cancel_scheduled_retunes(bladeRF.ref, C.bladerf_channel(channel)))
}
func GetFpgaSource(bladeRF BladeRF) (FpgaSource, error) {
func (bladeRF *BladeRF) GetFpgaSource() (FpgaSource, error) {
var source C.bladerf_fpga_source
err := GetError(C.bladerf_get_fpga_source(bladeRF.ref, &source))
@ -93,7 +95,7 @@ func GetFpgaSource(bladeRF BladeRF) (FpgaSource, error) {
return FpgaSource(source), nil
}
func GetFpgaBytes(bladeRF BladeRF) (uint32, error) {
func (bladeRF *BladeRF) GetFpgaBytes() (uint32, error) {
var size C.size_t
err := GetError(C.bladerf_get_fpga_bytes(bladeRF.ref, &size))
@ -104,7 +106,7 @@ func GetFpgaBytes(bladeRF BladeRF) (uint32, error) {
return uint32(size), nil
}
func GetFpgaFlashSize(bladeRF BladeRF) (uint32, bool, error) {
func (bladeRF *BladeRF) GetFpgaFlashSize() (uint32, bool, error) {
var size C.uint32_t
var isGuess C.bool
err := GetError(C.bladerf_get_flash_size(bladeRF.ref, &size, &isGuess))
@ -116,7 +118,7 @@ func GetFpgaFlashSize(bladeRF BladeRF) (uint32, bool, error) {
return uint32(size), bool(isGuess), nil
}
func GetFirmwareVersion(bladeRF BladeRF) (Version, error) {
func (bladeRF *BladeRF) GetFirmwareVersion() (Version, error) {
var version C.struct_bladerf_version
err := GetError(C.bladerf_fw_version(bladeRF.ref, &version))
@ -127,7 +129,7 @@ func GetFirmwareVersion(bladeRF BladeRF) (Version, error) {
return NewVersion(&version), nil
}
func IsFpgaConfigured(bladeRF BladeRF) (bool, error) {
func (bladeRF *BladeRF) IsFpgaConfigured() (bool, error) {
out := C.bladerf_is_fpga_configured(bladeRF.ref)
if out < 0 {
@ -137,11 +139,11 @@ func IsFpgaConfigured(bladeRF BladeRF) (bool, error) {
return out == 1, nil
}
func GetDeviceSpeed(bladeRF BladeRF) DeviceSpeed {
func (bladeRF *BladeRF) GetDeviceSpeed() DeviceSpeed {
return DeviceSpeed(int(C.bladerf_device_speed(bladeRF.ref)))
}
func GetFpgaVersion(bladeRF BladeRF) (Version, error) {
func (bladeRF *BladeRF) GetFpgaVersion() (Version, error) {
var version C.struct_bladerf_version
err := GetError(C.bladerf_fpga_version(bladeRF.ref, &version))
@ -152,7 +154,7 @@ func GetFpgaVersion(bladeRF BladeRF) (Version, error) {
return NewVersion(&version), nil
}
func FreeDeviceList(deviceInfo DeviceInfo) {
func (deviceInfo *DeviceInfo) FreeDeviceList() {
C.bladerf_free_device_list(deviceInfo.ref)
}
@ -181,7 +183,7 @@ func GetDeviceList() ([]DeviceInfo, error) {
))
}
FreeDeviceList(devices[0])
devices[0].FreeDeviceList()
}
return devices, nil
@ -212,7 +214,7 @@ func GetBootloaderList() ([]DeviceInfo, error) {
))
}
FreeDeviceList(devices[0])
devices[0].FreeDeviceList()
}
return devices, nil
@ -224,7 +226,7 @@ func InitDeviceInfo() DeviceInfo {
return NewDeviceInfo(&deviceInfo)
}
func GetDeviceInfo(bladeRF BladeRF) (DeviceInfo, error) {
func (bladeRF *BladeRF) GetDeviceInfo() (DeviceInfo, error) {
var deviceInfo C.struct_bladerf_devinfo
err := GetError(C.bladerf_get_devinfo(bladeRF.ref, &deviceInfo))
@ -235,11 +237,11 @@ func GetDeviceInfo(bladeRF BladeRF) (DeviceInfo, error) {
return NewDeviceInfo(&deviceInfo), nil
}
func DeviceInfoMatches(a DeviceInfo, b DeviceInfo) bool {
return bool(C.bladerf_devinfo_matches(a.ref, b.ref))
func (deviceInfo *DeviceInfo) DeviceInfoMatches(target DeviceInfo) bool {
return bool(C.bladerf_devinfo_matches(deviceInfo.ref, target.ref))
}
func DeviceStringMatches(deviceString string, deviceInfo DeviceInfo) bool {
func (deviceInfo *DeviceInfo) DeviceStringMatches(deviceString string) bool {
val := C.CString(deviceString)
defer C.free(unsafe.Pointer(val))
@ -260,7 +262,7 @@ func GetDeviceInfoFromString(deviceString string) (DeviceInfo, error) {
return NewDeviceInfo(&deviceInfo), nil
}
func OpenWithDeviceInfo(deviceInfo DeviceInfo) (BladeRF, error) {
func (deviceInfo *DeviceInfo) Open() (BladeRF, error) {
var bladeRF *C.struct_bladerf
err := GetError(C.bladerf_open_with_devinfo(&bladeRF, deviceInfo.ref))
@ -293,19 +295,19 @@ func Open() (BladeRF, error) {
return BladeRF{ref: bladeRF}, nil
}
func Close(bladeRF BladeRF) {
func (bladeRF *BladeRF) Close() {
C.bladerf_close(bladeRF.ref)
}
func SetLoopback(bladeRF BladeRF, loopback Loopback) error {
func (bladeRF *BladeRF) SetLoopback(loopback Loopback) error {
return GetError(C.bladerf_set_loopback(bladeRF.ref, C.bladerf_loopback(loopback)))
}
func IsLoopbackModeSupported(bladeRF BladeRF, loopback Loopback) bool {
func (bladeRF *BladeRF) IsLoopbackModeSupported(loopback Loopback) bool {
return bool(C.bladerf_is_loopback_mode_supported(bladeRF.ref, C.bladerf_loopback(loopback)))
}
func GetLoopback(bladeRF BladeRF) (Loopback, error) {
func (bladeRF *BladeRF) GetLoopback() (Loopback, error) {
var loopback C.bladerf_loopback
err := GetError(C.bladerf_get_loopback(bladeRF.ref, &loopback))
@ -316,19 +318,30 @@ func GetLoopback(bladeRF BladeRF) (Loopback, error) {
return Loopback(loopback), nil
}
func ScheduleReTune(bladeRF BladeRF, channel Channel, timestamp Timestamp, frequency uint64, quickTune QuickTune) error {
return GetError(C.bladerf_schedule_retune(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_timestamp(timestamp), C.bladerf_frequency(frequency), quickTune.ref))
func (bladeRF *BladeRF) ScheduleReTune(
channel Channel,
timestamp Timestamp,
frequency uint64,
quickTune QuickTune,
) error {
return GetError(C.bladerf_schedule_retune(
bladeRF.ref,
C.bladerf_channel(channel),
C.bladerf_timestamp(timestamp),
C.bladerf_frequency(frequency),
quickTune.ref,
))
}
func SelectBand(bladeRF BladeRF, channel Channel, frequency uint64) error {
func (bladeRF *BladeRF) SelectBand(channel Channel, frequency uint64) error {
return GetError(C.bladerf_select_band(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_frequency(frequency)))
}
func SetFrequency(bladeRF BladeRF, channel Channel, frequency uint64) error {
func (bladeRF *BladeRF) SetFrequency(channel Channel, frequency uint64) error {
return GetError(C.bladerf_set_frequency(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_frequency(frequency)))
}
func GetFrequency(bladeRF BladeRF, channel Channel) (uint64, error) {
func (bladeRF *BladeRF) GetFrequency(channel Channel) (uint64, error) {
var frequency C.uint64_t
err := GetError(C.bladerf_get_frequency(bladeRF.ref, C.bladerf_channel(channel), &frequency))
@ -339,9 +352,14 @@ func GetFrequency(bladeRF BladeRF, channel Channel) (uint64, error) {
return uint64(frequency), nil
}
func SetSampleRate(bladeRF BladeRF, channel Channel, sampleRate uint) (uint, error) {
func (bladeRF *BladeRF) SetSampleRate(channel Channel, sampleRate uint) (uint, error) {
var actual C.uint
err := GetError(C.bladerf_set_sample_rate(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_sample_rate(sampleRate), &actual))
err := GetError(C.bladerf_set_sample_rate(
bladeRF.ref,
C.bladerf_channel(channel),
C.bladerf_sample_rate(sampleRate),
&actual),
)
if err != nil {
return 0, err
@ -350,11 +368,11 @@ func SetSampleRate(bladeRF BladeRF, channel Channel, sampleRate uint) (uint, err
return uint(actual), nil
}
func SetRxMux(bladeRF BladeRF, mux RxMux) error {
func (bladeRF *BladeRF) SetRxMux(mux RxMux) error {
return GetError(C.bladerf_set_rx_mux(bladeRF.ref, C.bladerf_rx_mux(mux)))
}
func GetRxMux(bladeRF BladeRF) (RxMux, error) {
func (bladeRF *BladeRF) GetRxMux() (RxMux, error) {
var rxMux C.bladerf_rx_mux
err := GetError(C.bladerf_get_rx_mux(bladeRF.ref, &rxMux))
@ -365,14 +383,19 @@ func GetRxMux(bladeRF BladeRF) (RxMux, error) {
return RxMux(rxMux), nil
}
func SetRationalSampleRate(bladeRF BladeRF, channel Channel, rationalRate RationalRate) (RationalRate, error) {
func (bladeRF *BladeRF) SetRationalSampleRate(channel Channel, rationalRate RationalRate) (RationalRate, error) {
var actual C.struct_bladerf_rational_rate
rationalSampleRate := C.struct_bladerf_rational_rate{
num: C.uint64_t(rationalRate.num),
integer: C.uint64_t(rationalRate.integer),
den: C.uint64_t(rationalRate.den),
}
err := GetError(C.bladerf_set_rational_sample_rate(bladeRF.ref, C.bladerf_channel(channel), &rationalSampleRate, &actual))
err := GetError(C.bladerf_set_rational_sample_rate(
bladeRF.ref,
C.bladerf_channel(channel),
&rationalSampleRate,
&actual),
)
if err != nil {
return RationalRate{}, err
@ -381,7 +404,7 @@ func SetRationalSampleRate(bladeRF BladeRF, channel Channel, rationalRate Ration
return NewRationalRate(&actual), nil
}
func GetSampleRate(bladeRF BladeRF, channel Channel) (uint, error) {
func (bladeRF *BladeRF) GetSampleRate(channel Channel) (uint, error) {
var sampleRate C.uint
err := GetError(C.bladerf_get_sample_rate(bladeRF.ref, C.bladerf_channel(channel), &sampleRate))
@ -392,7 +415,7 @@ func GetSampleRate(bladeRF BladeRF, channel Channel) (uint, error) {
return uint(sampleRate), nil
}
func GetRationalSampleRate(bladeRF BladeRF, channel Channel) (RationalRate, error) {
func (bladeRF *BladeRF) GetRationalSampleRate(channel Channel) (RationalRate, error) {
var rate C.struct_bladerf_rational_rate
err := GetError(C.bladerf_get_rational_sample_rate(bladeRF.ref, C.bladerf_channel(channel), &rate))
@ -403,7 +426,7 @@ func GetRationalSampleRate(bladeRF BladeRF, channel Channel) (RationalRate, erro
return NewRationalRate(&rate), nil
}
func GetSampleRateRange(bladeRF BladeRF, channel Channel) (Range, error) {
func (bladeRF *BladeRF) GetSampleRateRange(channel Channel) (Range, error) {
var _range *C.struct_bladerf_range
err := GetError(C.bladerf_get_sample_rate_range(bladeRF.ref, C.bladerf_channel(channel), &_range))
@ -414,7 +437,7 @@ func GetSampleRateRange(bladeRF BladeRF, channel Channel) (Range, error) {
return NewRange(_range), nil
}
func GetFrequencyRange(bladeRF BladeRF, channel Channel) (Range, error) {
func (bladeRF *BladeRF) GetFrequencyRange(channel Channel) (Range, error) {
var _range *C.struct_bladerf_range
err := GetError(C.bladerf_get_frequency_range(bladeRF.ref, C.bladerf_channel(channel), &_range))
@ -425,9 +448,14 @@ func GetFrequencyRange(bladeRF BladeRF, channel Channel) (Range, error) {
return NewRange(_range), nil
}
func SetBandwidth(bladeRF BladeRF, channel Channel, bandwidth uint) (uint, error) {
func (bladeRF *BladeRF) SetBandwidth(channel Channel, bandwidth uint) (uint, error) {
var actual C.bladerf_bandwidth
err := GetError(C.bladerf_set_bandwidth(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_bandwidth(bandwidth), &actual))
err := GetError(C.bladerf_set_bandwidth(
bladeRF.ref,
C.bladerf_channel(channel),
C.bladerf_bandwidth(bandwidth),
&actual),
)
if err != nil {
return 0, err
@ -436,7 +464,7 @@ func SetBandwidth(bladeRF BladeRF, channel Channel, bandwidth uint) (uint, error
return uint(actual), nil
}
func GetBandwidth(bladeRF BladeRF, channel Channel) (uint, error) {
func (bladeRF *BladeRF) GetBandwidth(channel Channel) (uint, error) {
var bandwidth C.bladerf_bandwidth
err := GetError(C.bladerf_get_bandwidth(bladeRF.ref, C.bladerf_channel(channel), &bandwidth))
@ -447,7 +475,7 @@ func GetBandwidth(bladeRF BladeRF, channel Channel) (uint, error) {
return uint(bandwidth), nil
}
func GetBandwidthRange(bladeRF BladeRF, channel Channel) (Range, error) {
func (bladeRF *BladeRF) GetBandwidthRange(channel Channel) (Range, error) {
var bfRange *C.struct_bladerf_range
err := GetError(C.bladerf_get_bandwidth_range(bladeRF.ref, C.bladerf_channel(channel), &bfRange))
@ -458,11 +486,11 @@ func GetBandwidthRange(bladeRF BladeRF, channel Channel) (Range, error) {
return NewRange(bfRange), nil
}
func SetGain(bladeRF BladeRF, channel Channel, gain int) error {
func (bladeRF *BladeRF) SetGain(channel Channel, gain int) error {
return GetError(C.bladerf_set_gain(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_gain(gain)))
}
func GetGain(bladeRF BladeRF, channel Channel) (int, error) {
func (bladeRF *BladeRF) GetGain(channel Channel) (int, error) {
var gain C.bladerf_gain
err := GetError(C.bladerf_get_gain(bladeRF.ref, C.bladerf_channel(channel), &gain))
@ -473,7 +501,7 @@ func GetGain(bladeRF BladeRF, channel Channel) (int, error) {
return int(gain), nil
}
func GetGainStage(bladeRF BladeRF, channel Channel, stage string) (int, error) {
func (bladeRF *BladeRF) GetGainStage(channel Channel, stage string) (int, error) {
val := C.CString(stage)
defer C.free(unsafe.Pointer(val))
@ -487,7 +515,7 @@ func GetGainStage(bladeRF BladeRF, channel Channel, stage string) (int, error) {
return int(gain), nil
}
func GetGainMode(bladeRF BladeRF, channel Channel) (GainMode, error) {
func (bladeRF *BladeRF) GetGainMode(channel Channel) (GainMode, error) {
var mode C.bladerf_gain_mode
err := GetError(C.bladerf_get_gain_mode(bladeRF.ref, C.bladerf_channel(channel), &mode))
@ -499,14 +527,14 @@ func GetGainMode(bladeRF BladeRF, channel Channel) (GainMode, error) {
return GainMode(mode), nil
}
func SetGainStage(bladeRF BladeRF, channel Channel, stage string, gain int) error {
func (bladeRF *BladeRF) SetGainStage(channel Channel, stage string, gain int) error {
val := C.CString(stage)
defer C.free(unsafe.Pointer(val))
return GetError(C.bladerf_set_gain_stage(bladeRF.ref, C.bladerf_channel(channel), val, C.bladerf_gain(gain)))
}
func GetGainStageRange(bladeRF BladeRF, channel Channel, stage string) (Range, error) {
func (bladeRF *BladeRF) GetGainStageRange(channel Channel, stage string) (Range, error) {
val := C.CString(stage)
defer C.free(unsafe.Pointer(val))
@ -520,7 +548,7 @@ func GetGainStageRange(bladeRF BladeRF, channel Channel, stage string) (Range, e
return NewRange(_range), nil
}
func GetGainRange(bladeRF BladeRF, channel Channel) (Range, error) {
func (bladeRF *BladeRF) GetGainRange(channel Channel) (Range, error) {
var _range *C.struct_bladerf_range
err := GetError(C.bladerf_get_gain_range(bladeRF.ref, C.bladerf_channel(channel), &_range))
@ -531,7 +559,7 @@ func GetGainRange(bladeRF BladeRF, channel Channel) (Range, error) {
return NewRange(_range), nil
}
func GetNumberOfGainStages(bladeRF BladeRF, channel Channel) (int, error) {
func (bladeRF *BladeRF) GetNumberOfGainStages(channel Channel) (int, error) {
countOrCode := C.bladerf_get_gain_stages(bladeRF.ref, C.bladerf_channel(channel), nil, 0)
if countOrCode < 0 {
@ -541,13 +569,23 @@ func GetNumberOfGainStages(bladeRF BladeRF, channel Channel) (int, error) {
return int(countOrCode), nil
}
func SetCorrection(bladeRF BladeRF, channel Channel, correction Correction, correctionValue int16) error {
return GetError(C.bladerf_set_correction(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_correction(correction), C.bladerf_correction_value(correctionValue)))
func (bladeRF *BladeRF) SetCorrection(channel Channel, correction Correction, correctionValue int16) error {
return GetError(C.bladerf_set_correction(
bladeRF.ref,
C.bladerf_channel(channel),
C.bladerf_correction(correction),
C.bladerf_correction_value(correctionValue)),
)
}
func GetCorrection(bladeRF BladeRF, channel Channel, correction Correction) (uint16, error) {
func (bladeRF *BladeRF) GetCorrection(channel Channel, correction Correction) (uint16, error) {
var correctionValue C.int16_t
err := GetError(C.bladerf_get_correction(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_correction(correction), &correctionValue))
err := GetError(C.bladerf_get_correction(
bladeRF.ref,
C.bladerf_channel(channel),
C.bladerf_correction(correction),
&correctionValue),
)
if err != nil {
return 0, err
@ -556,11 +594,11 @@ func GetCorrection(bladeRF BladeRF, channel Channel, correction Correction) (uin
return uint16(correctionValue), nil
}
func BackendString(backend Backend) string {
return C.GoString(C.bladerf_backend_str(C.bladerf_backend(backend)))
func (backend *Backend) String() string {
return C.GoString(C.bladerf_backend_str(C.bladerf_backend(*backend)))
}
func GetBoardName(bladeRF BladeRF) string {
func (bladeRF *BladeRF) GetBoardName() string {
return C.GoString(C.bladerf_get_board_name(bladeRF.ref))
}
@ -568,7 +606,7 @@ func SetUSBResetOnOpen(enabled bool) {
C.bladerf_set_usb_reset_on_open(C.bool(enabled))
}
func GetSerial(bladeRF BladeRF) (string, error) {
func (bladeRF *BladeRF) GetSerial() (string, error) {
var serial C.char
err := GetError(C.bladerf_get_serial(bladeRF.ref, &serial))
@ -579,7 +617,7 @@ func GetSerial(bladeRF BladeRF) (string, error) {
return C.GoString(&serial), nil
}
func GetSerialStruct(bladeRF BladeRF) (Serial, error) {
func (bladeRF *BladeRF) GetSerialStruct() (Serial, error) {
var serial C.struct_bladerf_serial
err := GetError(C.bladerf_get_serial_struct(bladeRF.ref, &serial))
@ -590,11 +628,11 @@ func GetSerialStruct(bladeRF BladeRF) (Serial, error) {
return NewSerial(&serial), nil
}
func GetGainStages(bladeRF BladeRF, channel Channel) ([]string, error) {
func (bladeRF *BladeRF) GetGainStages(channel Channel) ([]string, error) {
var stage *C.char
var stages []string
numberOfGainStages, err := GetNumberOfGainStages(bladeRF, channel)
numberOfGainStages, err := bladeRF.GetNumberOfGainStages(channel)
if err != nil {
return nil, err
@ -630,7 +668,7 @@ func GetGainStages(bladeRF BladeRF, channel Channel) ([]string, error) {
return stages, nil
}
func GetGainModes(bladeRF BladeRF, channel Channel) ([]GainModes, error) {
func (bladeRF *BladeRF) GetGainModes(channel Channel) ([]GainModes, error) {
var gainMode *C.struct_bladerf_gain_modes
var gainModes []GainModes
@ -659,7 +697,7 @@ func GetGainModes(bladeRF BladeRF, channel Channel) ([]GainModes, error) {
return gainModes, nil
}
func GetLoopbackModes(bladeRF BladeRF) ([]LoopbackModes, error) {
func (bladeRF *BladeRF) GetLoopbackModes() ([]LoopbackModes, error) {
var loopbackMode *C.struct_bladerf_loopback_modes
var loopbackModes []LoopbackModes
@ -680,7 +718,9 @@ func GetLoopbackModes(bladeRF BladeRF) ([]LoopbackModes, error) {
for i := 0; i < count; i++ {
loopbackModes = append(loopbackModes, NewLoopbackModes(
(*C.struct_bladerf_loopback_modes)(unsafe.Pointer(uintptr(unsafe.Pointer(loopbackMode))+(uintptr(i)*size))),
(*C.struct_bladerf_loopback_modes)(
unsafe.Pointer(uintptr(unsafe.Pointer(loopbackMode))+(uintptr(i)*size)),
),
))
}
}
@ -688,21 +728,26 @@ func GetLoopbackModes(bladeRF BladeRF) ([]LoopbackModes, error) {
return loopbackModes, nil
}
func SetGainMode(bladeRF BladeRF, channel Channel, mode GainMode) error {
func (bladeRF *BladeRF) SetGainMode(channel Channel, mode GainMode) error {
return GetError(C.bladerf_set_gain_mode(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_gain_mode(mode)))
}
func EnableModule(bladeRF BladeRF, channel Channel) error {
func (bladeRF *BladeRF) EnableModule(channel Channel) error {
return GetError(C.bladerf_enable_module(bladeRF.ref, C.bladerf_channel(channel), true))
}
func DisableModule(bladeRF BladeRF, channel Channel) error {
func (bladeRF *BladeRF) DisableModule(channel Channel) error {
return GetError(C.bladerf_enable_module(bladeRF.ref, C.bladerf_channel(channel), false))
}
func TriggerInit(bladeRF BladeRF, channel Channel, signal TriggerSignal) (Trigger, error) {
func (bladeRF *BladeRF) TriggerInit(channel Channel, signal TriggerSignal) (Trigger, error) {
var trigger C.struct_bladerf_trigger
err := GetError(C.bladerf_trigger_init(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_trigger_signal(signal), &trigger))
err := GetError(C.bladerf_trigger_init(
bladeRF.ref,
C.bladerf_channel(channel),
C.bladerf_trigger_signal(signal),
&trigger),
)
if err != nil {
return Trigger{}, err
@ -711,22 +756,30 @@ func TriggerInit(bladeRF BladeRF, channel Channel, signal TriggerSignal) (Trigge
return Trigger{ref: &trigger}, nil
}
func TriggerArm(bladeRF BladeRF, trigger Trigger, arm bool, resV1 uint64, resV2 uint64) error {
func (bladeRF *BladeRF) TriggerArm(trigger Trigger, arm bool, resV1 uint64, resV2 uint64) error {
return GetError(C.bladerf_trigger_arm(bladeRF.ref, trigger.ref, C.bool(arm), C.uint64_t(resV1), C.uint64_t(resV2)))
}
func TriggerFire(bladeRF BladeRF, trigger Trigger) error {
func (bladeRF *BladeRF) TriggerFire(trigger Trigger) error {
return GetError(C.bladerf_trigger_fire(bladeRF.ref, trigger.ref))
}
func TriggerState(bladeRF BladeRF, trigger Trigger) (bool, bool, bool, uint64, uint64, error) {
func (bladeRF *BladeRF) TriggerState(trigger Trigger) (bool, bool, bool, uint64, uint64, error) {
var isArmed C.bool
var hasFired C.bool
var fireRequested C.bool
var resV1 C.uint64_t
var resV2 C.uint64_t
err := GetError(C.bladerf_trigger_state(bladeRF.ref, trigger.ref, &isArmed, &hasFired, &fireRequested, &resV1, &resV2))
err := GetError(C.bladerf_trigger_state(
bladeRF.ref,
trigger.ref,
&isArmed,
&hasFired,
&fireRequested,
&resV1,
&resV2),
)
if err != nil {
return false, false, false, 0, 0, err
@ -735,7 +788,11 @@ func TriggerState(bladeRF BladeRF, trigger Trigger) (bool, bool, bool, uint64, u
return bool(isArmed), bool(hasFired), bool(fireRequested), uint64(resV1), uint64(resV2), nil
}
func SyncRX(bladeRF BladeRF, bufferSize uintptr) ([]int16, error) {
func (trigger *Trigger) SetRole(role TriggerRole) {
(*trigger.ref).role = C.bladerf_trigger_role(role)
}
func (bladeRF *BladeRF) SyncRX(bufferSize uintptr) ([]int16, error) {
var metadata C.struct_bladerf_metadata
start := C.malloc(C.size_t(C.sizeof_int16_t * bufferSize * 2 * 1))
err := GetError(C.bladerf_sync_rx(bladeRF.ref, start, C.uint(bufferSize), &metadata, 32))
@ -754,9 +811,13 @@ func SyncRX(bladeRF BladeRF, bufferSize uintptr) ([]int16, error) {
return results, nil
}
func InitStream(bladeRF BladeRF,
func (bladeRF *BladeRF) InitStream(
format Format,
numBuffers int, samplesPerBuffer int, numTransfers int, callback func(data []int16)) (Stream, error) {
numBuffers int,
samplesPerBuffer int,
numTransfers int,
callback func(data []int16),
) (Stream, error) {
var buffers *unsafe.Pointer
var rxStream *C.struct_bladerf_stream
@ -781,11 +842,11 @@ func InitStream(bladeRF BladeRF,
return stream, nil
}
func DeInitStream(stream Stream) {
func (stream *Stream) DeInit() {
C.bladerf_deinit_stream(stream.ref)
}
func GetStreamTimeout(bladeRF BladeRF, direction Direction) (uint, error) {
func (bladeRF *BladeRF) GetStreamTimeout(direction Direction) (uint, error) {
var timeout C.uint
err := GetError(C.bladerf_get_stream_timeout(bladeRF.ref, C.bladerf_direction(direction), &timeout))
@ -796,23 +857,38 @@ func GetStreamTimeout(bladeRF BladeRF, direction Direction) (uint, error) {
return uint(timeout), err
}
func SetStreamTimeout(bladeRF BladeRF, direction Direction, timeout uint) error {
func (bladeRF *BladeRF) SetStreamTimeout(direction Direction, timeout uint) error {
return GetError(C.bladerf_set_stream_timeout(bladeRF.ref, C.bladerf_direction(direction), C.uint(timeout)))
}
func SyncConfig(bladeRF BladeRF, layout ChannelLayout, format Format, numBuffers uint, bufferSize uint, numTransfers uint, timeout uint) error {
return GetError(C.bladerf_sync_config(bladeRF.ref, C.bladerf_channel_layout(layout), C.bladerf_format(format), C.uint(numBuffers), C.uint(bufferSize), C.uint(numTransfers), C.uint(timeout)))
func (bladeRF *BladeRF) SyncConfig(
layout ChannelLayout,
format Format,
numBuffers uint,
bufferSize uint,
numTransfers uint,
timeout uint,
) error {
return GetError(C.bladerf_sync_config(
bladeRF.ref,
C.bladerf_channel_layout(layout),
C.bladerf_format(format),
C.uint(numBuffers),
C.uint(bufferSize),
C.uint(numTransfers),
C.uint(timeout)),
)
}
func StartStream(stream Stream, layout ChannelLayout) error {
func (stream *Stream) Start(layout ChannelLayout) error {
return GetError(C.bladerf_stream(stream.ref, C.bladerf_channel_layout(layout)))
}
func AttachExpansionBoard(bladeRF BladeRF, expansionBoard ExpansionBoard) error {
func (bladeRF *BladeRF) AttachExpansionBoard(expansionBoard ExpansionBoard) error {
return GetError(C.bladerf_expansion_attach(bladeRF.ref, C.bladerf_xb(expansionBoard)))
}
func GetAttachedExpansionBoard(bladeRF BladeRF) (ExpansionBoard, error) {
func (bladeRF *BladeRF) GetAttachedExpansionBoard() (ExpansionBoard, error) {
var expansionBoard C.bladerf_xb
err := GetError(C.bladerf_expansion_get_attached(bladeRF.ref, &expansionBoard))
@ -822,3 +898,44 @@ func GetAttachedExpansionBoard(bladeRF BladeRF) (ExpansionBoard, error) {
return ExpansionBoard(expansionBoard), nil
}
func (bladeRF *BladeRF) SetGetVctcxoTamerMode(mode VctcxoTamerMode) error {
return GetError(C.bladerf_set_vctcxo_tamer_mode(bladeRF.ref, C.bladerf_vctcxo_tamer_mode(mode)))
}
func (bladeRF *BladeRF) GetVctcxoTamerMode() (VctcxoTamerMode, error) {
var mode C.bladerf_vctcxo_tamer_mode
err := GetError(C.bladerf_get_vctcxo_tamer_mode(bladeRF.ref, &mode))
if err != nil {
return 0, err
}
return VctcxoTamerMode(mode), nil
}
func (bladeRF *BladeRF) GetVctcxoTrim() (uint16, error) {
var trim C.uint16_t
err := GetError(C.bladerf_get_vctcxo_trim(bladeRF.ref, &trim))
if err != nil {
return 0, err
}
return uint16(trim), nil
}
func (bladeRF *BladeRF) TrimDacRead() (uint16, error) {
var val C.uint16_t
err := GetError(C.bladerf_trim_dac_read(bladeRF.ref, &val))
if err != nil {
return 0, err
}
return uint16(val), nil
}
func (bladeRF *BladeRF) TrimDacWrite(val uint16) error {
return GetError(C.bladerf_trim_dac_write(bladeRF.ref, C.uint16_t(val)))
}

243
bladerf_test.go
View File

@ -56,12 +56,12 @@ func GetFinalDataString(input []int16) string {
}
func TestBackendSTR(t *testing.T) {
x := BackendString(BackendLibUSB)
y := BackendString(BackendDummy)
z := BackendString(BackendAny)
a := BackendString(BackendCypress)
b := BackendString(BackendLinux)
fmt.Println(x, y, z, a, b)
x := BackendLibUSB
y := BackendDummy
z := BackendAny
a := BackendCypress
b := BackendLinux
fmt.Println(x.String(), y.String(), z.String(), a.String(), b.String())
}
func TestSetUSBResetOnOpen(t *testing.T) {
@ -79,10 +79,10 @@ func TestGetSerial(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
serial, _ := GetSerial(rf)
serial, _ := rf.GetSerial()
fmt.Println(serial)
}
@ -96,10 +96,10 @@ func TestGetSerialStruct(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
serial, _ := GetSerialStruct(rf)
serial, _ := rf.GetSerialStruct()
fmt.Print(serial)
}
@ -113,10 +113,10 @@ func TestGetFpgaSize(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
size, _ := GetFpgaSize(rf)
size, _ := rf.GetFpgaSize()
fmt.Print(size)
}
@ -130,10 +130,10 @@ func TestGetFpgaSource(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
source, _ := GetFpgaSource(rf)
source, _ := rf.GetFpgaSource()
fmt.Print(source)
}
@ -147,10 +147,10 @@ func TestGetDeviceSpeed(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
speed := GetDeviceSpeed(rf)
speed := rf.GetDeviceSpeed()
fmt.Print(speed)
}
@ -164,10 +164,10 @@ func TestGetBoardName(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
name := GetBoardName(rf)
name := rf.GetBoardName()
fmt.Print(name)
}
@ -181,10 +181,10 @@ func TestGetRationalSampleRate(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
rate, _ := GetRationalSampleRate(rf, ChannelRx(1))
rate, _ := rf.GetRationalSampleRate(ChannelRx(1))
fmt.Print(rate)
}
@ -198,10 +198,10 @@ func TestGetFpgaBytes(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
bytes, _ := GetFpgaBytes(rf)
bytes, _ := rf.GetFpgaBytes()
fmt.Print(bytes)
}
@ -215,10 +215,10 @@ func TestGetFpgaFlashSize(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
size, guess, err := GetFpgaFlashSize(rf)
size, guess, err := rf.GetFpgaFlashSize()
if err != nil {
panic(err)
@ -238,10 +238,10 @@ func TestGetFirmwareVersion(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
version, err := GetFirmwareVersion(rf)
version, err := rf.GetFirmwareVersion()
if err != nil {
panic(err)
@ -260,10 +260,10 @@ func TestGetFpgaVersion(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
version, _ := GetFpgaVersion(rf)
version, _ := rf.GetFpgaVersion()
fmt.Print(version.describe)
}
@ -277,10 +277,10 @@ func TestGetLoopbackModes(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
modes, _ := GetLoopbackModes(rf)
modes, _ := rf.GetLoopbackModes()
for _, v := range modes {
fmt.Printf("%s\n\n", v.name)
}
@ -296,18 +296,18 @@ func TestGetQuickTune(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
channel := ChannelRx(1)
quickTune, err := GetQuickTune(rf, channel)
quickTune, err := rf.GetQuickTune(channel)
if err != nil {
panic(err)
}
err = ScheduleReTune(rf, channel, ReTuneNow, 96600000, quickTune)
err = rf.ScheduleReTune(channel, ReTuneNow, 96600000, quickTune)
if err != nil {
panic(err)
@ -324,10 +324,10 @@ func TestExpansionBoard(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
board, err := GetAttachedExpansionBoard(rf)
board, err := rf.GetAttachedExpansionBoard()
if err != nil {
panic(err)
@ -350,13 +350,13 @@ func TestTrigger(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
channel := ChannelRx(0)
signal := TriggerSignalJ714
triggerMaster, err := TriggerInit(rf, channel, signal)
triggerMaster, err := rf.TriggerInit(channel, signal)
if err != nil {
panic(err)
@ -364,7 +364,7 @@ func TestTrigger(t *testing.T) {
triggerMaster.SetRole(TriggerRoleMaster)
triggerSlave, err := TriggerInit(rf, channel, signal)
triggerSlave, err := rf.TriggerInit(channel, signal)
if err != nil {
panic(err)
@ -372,19 +372,19 @@ func TestTrigger(t *testing.T) {
triggerSlave.SetRole(TriggerRoleSlave)
err = TriggerArm(rf, triggerMaster, true, 0, 0)
err = rf.TriggerArm(triggerMaster, true, 0, 0)
if err != nil {
panic(err)
}
err = TriggerFire(rf, triggerMaster)
err = rf.TriggerFire(triggerMaster)
if err != nil {
panic(err)
}
a, b, c, x, y, err := TriggerState(rf, triggerMaster)
a, b, c, x, y, err := rf.TriggerState(triggerMaster)
if err != nil {
panic(err)
@ -403,10 +403,10 @@ func TestIsFpgaConfigured(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
isConfigured, err := IsFpgaConfigured(rf)
isConfigured, err := rf.IsFpgaConfigured()
if err != nil {
panic(err)
@ -418,50 +418,51 @@ func TestIsFpgaConfigured(t *testing.T) {
func TestBladeRF(t *testing.T) {
log.SetVerbosity(log.Error)
PrintVersion(GetVersion())
version := GetVersion()
version.Print()
bootloaders, _ := GetBootloaderList()
fmt.Printf("Bootloaders Len: %d\n", len(bootloaders))
devices, _ := GetDeviceList()
fmt.Printf("Devices Len: %d\n", len(devices))
rf, _ := OpenWithDeviceInfo(devices[0])
_ = LoadFpga(rf, "/Users/erayarslan/Downloads/hostedxA4-latest.rbf")
Close(rf)
rf, _ := devices[0].Open()
_ = rf.LoadFpga("/Users/erayarslan/Downloads/hostedxA4-latest.rbf")
rf.Close()
rf, _ = Open()
info, _ := GetDeviceInfo(rf)
Close(rf)
h, _ := GetDeviceInfo(rf)
out, _ := OpenWithDeviceInfo(h)
Close(out)
info, _ := rf.GetDeviceInfo()
rf.Close()
h, _ := rf.GetDeviceInfo()
out, _ := h.Open()
out.Close()
c1, _ := Open()
Close(c1)
c1.Close()
c2, _ := OpenWithDeviceIdentifier("*:serial=" + info.serial)
Close(c2)
c2.Close()
o1, _ := GetDeviceInfoFromString("*:serial=" + info.serial)
out2, _ := OpenWithDeviceInfo(o1)
Close(out2)
out2, _ := o1.Open()
out2.Close()
g, _ := GetDeviceInfo(rf)
result := DeviceInfoMatches(g, g)
g, _ := rf.GetDeviceInfo()
result := g.DeviceInfoMatches(g)
fmt.Println("---------")
fmt.Println(result)
fmt.Println("---------")
g0, _ := GetDeviceInfo(rf)
result = DeviceStringMatches("*:serial="+info.serial, g0)
g0, _ := rf.GetDeviceInfo()
result = g0.DeviceStringMatches("*:serial=" + info.serial)
fmt.Println("---------")
fmt.Println(result)
fmt.Println("---------")
rf, _ = Open()
err := EnableModule(rf, ChannelRx(1))
err := rf.EnableModule(ChannelRx(1))
if err != nil {
fmt.Println(err)
}
_, _ = InitStream(rf, FormatSc16Q11, 16, audioBufferSize, 8, cb)
_, _ = rf.InitStream(FormatSc16Q11, 16, audioBufferSize, 8, cb)
// _ = StartStream(stream, RX_X1)
}
@ -475,14 +476,14 @@ func TestSetGainStage(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
stages, _ := GetGainStages(rf, ChannelRx(1))
stages, _ := rf.GetGainStages(ChannelRx(1))
fmt.Println(len(stages))
bfRange, _ := GetGainStageRange(rf, ChannelRx(1), stages[0])
_ = SetGainStage(rf, ChannelRx(1), stages[0], int(bfRange.max))
gain, _ := GetGainStage(rf, ChannelRx(1), stages[0])
bfRange, _ := rf.GetGainStageRange(ChannelRx(1), stages[0])
_ = rf.SetGainStage(ChannelRx(1), stages[0], int(bfRange.max))
gain, _ := rf.GetGainStage(ChannelRx(1), stages[0])
fmt.Println(gain)
}
@ -512,18 +513,18 @@ func TestStream(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
_ = SetFrequency(rf, channel, 96600000)
_range, _ := GetSampleRateRange(rf, channel)
_ = rf.SetFrequency(channel, 96600000)
_range, _ := rf.GetSampleRateRange(channel)
fmt.Printf("Min: %d, Max: %d, Step: %d\n", _range.min, _range.max, _range.step)
_, _ = SetSampleRate(rf, channel, 4e6)
_ = SyncConfig(rf, RxX2, FormatSc16Q11, 16, audioBufferSize, 8, 32)
actual, _ := SetBandwidth(rf, channel, 240000)
_, _ = rf.SetSampleRate(channel, 4e6)
_ = rf.SyncConfig(RxX2, FormatSc16Q11, 16, audioBufferSize, 8, 32)
actual, _ := rf.SetBandwidth(channel, 240000)
fmt.Println(actual)
_ = EnableModule(rf, channel)
_ = SetGainMode(rf, channel, GainModeHybridAgc)
_ = rf.EnableModule(channel)
_ = rf.SetGainMode(channel, GainModeHybridAgc)
demodulator = demodcore.MakeWBFMDemodulator(uint32(2e6), 80e3, 48000)
@ -541,7 +542,7 @@ func TestStream(t *testing.T) {
go func() {
for {
data, _ := SyncRX(rf, audioBufferSize)
data, _ := rf.SyncRX(audioBufferSize)
out := demodulator.Work(GetFinalData(data))
if out != nil {
@ -584,10 +585,10 @@ func TestGetGainModes(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
_, _ = GetGainModes(rf, ChannelRx(1))
_, _ = rf.GetGainModes(ChannelRx(1))
}
func TestGetGainRange(t *testing.T) {
@ -600,10 +601,10 @@ func TestGetGainRange(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
bfRange, _ := GetGainRange(rf, ChannelRx(1))
bfRange, _ := rf.GetGainRange(ChannelRx(1))
fmt.Println(bfRange.max)
}
@ -618,18 +619,18 @@ func TestGPSData(t *testing.T) {
return
}
rf, _ := OpenWithDeviceInfo(devices[0])
defer Close(rf)
rf, _ := devices[0].Open()
defer rf.Close()
_ = SetFrequency(rf, channel, 1525420000)
_ = SyncConfig(rf, RxX2, FormatSc16Q11, 16, audioBufferSize, 8, 32)
_, _ = SetSampleRate(rf, channel, 2600000)
_, _ = SetBandwidth(rf, channel, 2500000)
_ = SetGainMode(rf, channel, GainModeHybridAgc)
_ = EnableModule(rf, channel)
_ = rf.SetFrequency(channel, 1525420000)
_ = rf.SyncConfig(RxX2, FormatSc16Q11, 16, audioBufferSize, 8, 32)
_, _ = rf.SetSampleRate(channel, 2600000)
_, _ = rf.SetBandwidth(channel, 2500000)
_ = rf.SetGainMode(channel, GainModeHybridAgc)
_ = rf.EnableModule(channel)
for {
data, _ := SyncRX(rf, audioBufferSize)
data, _ := rf.SyncRX(audioBufferSize)
out := GetFinalDataString(data)
fmt.Println(out)
}
@ -654,28 +655,28 @@ func TestAsyncStream(t *testing.T) {
return
}
rf, err := OpenWithDeviceInfo(devices[0])
rf, err := devices[0].Open()
if err != nil {
panic(err)
}
defer Close(rf)
defer rf.Close()
_ = SetFrequency(rf, channel, 96600000)
_, _ = SetSampleRate(rf, channel, 4e6)
_, _ = SetBandwidth(rf, channel, 240000)
_ = SetGainMode(rf, channel, GainModeHybridAgc)
_ = EnableModule(rf, channel)
_ = rf.SetFrequency(channel, 96600000)
_, _ = rf.SetSampleRate(channel, 4e6)
_, _ = rf.SetBandwidth(channel, 240000)
_ = rf.SetGainMode(channel, GainModeHybridAgc)
_ = rf.EnableModule(channel)
rxStream, err := InitStream(rf, FormatSc16Q11, 16, audioBufferSize, 8, cb)
rxStream, err := rf.InitStream(FormatSc16Q11, 16, audioBufferSize, 8, cb)
if err != nil {
panic(err)
}
defer DeInitStream(rxStream)
defer rxStream.DeInit()
_ = SetStreamTimeout(rf, Rx, 32)
timeout, _ := GetStreamTimeout(rf, Rx)
_ = rf.SetStreamTimeout(Rx, 32)
timeout, _ := rf.GetStreamTimeout(Rx)
println(timeout)
demodulator = demodcore.MakeWBFMDemodulator(uint32(2e6), 80e3, 48000)
@ -693,7 +694,7 @@ func TestAsyncStream(t *testing.T) {
_ = audioStream.Start()
go func() {
err = StartStream(rxStream, RxX2)
err = rxStream.Start(RxX2)
if err != nil {
panic(err)
}

8
enums.go
View File

@ -22,6 +22,7 @@ type RxMux int
type TriggerRole int
type TriggerSignal int
type ExpansionBoard int
type VctcxoTamerMode int
const (
BackendAny Backend = C.BLADERF_BACKEND_ANY
@ -157,3 +158,10 @@ const (
ExpansionBoard200 ExpansionBoard = C.BLADERF_XB_200
ExpansionBoard300 ExpansionBoard = C.BLADERF_XB_300
)
const (
VctcxoTamerModeInvalid VctcxoTamerMode = C.BLADERF_VCTCXO_TAMER_INVALID
VctcxoTamerModeDisabled VctcxoTamerMode = C.BLADERF_VCTCXO_TAMER_DISABLED
VctcxoTamerMode1Pps VctcxoTamerMode = C.BLADERF_VCTCXO_TAMER_1_PPS
VctcxoTamerMode10Mhz VctcxoTamerMode = C.BLADERF_VCTCXO_TAMER_10_MHZ
)

4
structs.go
View File

@ -126,10 +126,6 @@ type Trigger struct {
ref *C.struct_bladerf_trigger
}
func (trigger *Trigger) SetRole(role TriggerRole) {
(*trigger.ref).role = C.bladerf_trigger_role(role)
}
type LoopbackModes struct {
ref *C.struct_bladerf_loopback_modes
name string