From 7d632c6ad3f499638f323f21ebc77402f6fe403f Mon Sep 17 00:00:00 2001 From: Eray Arslan Date: Thu, 20 May 2021 01:16:00 +0300 Subject: [PATCH] refactor --- backend/backend.go | 14 - bladerf.go | 528 +++++++++++++++++++------------ bladerf_test.go | 253 ++++++++------- channel/channel.go | 3 - channel_layout/channel_layout.go | 13 - clock_select/clock_select.go | 12 - correction/correction.go | 13 - device_speed/device_speed.go | 12 - direction/direction.go | 11 - enums.go | 126 ++++++++ error/error.go | 4 +- format/format.go | 11 - fpga_size/fpga_size.go | 14 - fpga_source/fpga_source.go | 12 - gain_mode/gain_mode.go | 14 - io_module/io_module.go | 11 - loopback/loopback.go | 19 -- macros.go | 9 +- pmic_register/pmic_register.go | 15 - power_source/power_source.go | 12 - rx_mux/rx_mux.go | 14 - structs.go | 55 ++-- 22 files changed, 624 insertions(+), 551 deletions(-) delete mode 100644 backend/backend.go delete mode 100644 channel/channel.go delete mode 100644 channel_layout/channel_layout.go delete mode 100644 clock_select/clock_select.go delete mode 100644 correction/correction.go delete mode 100644 device_speed/device_speed.go delete mode 100644 direction/direction.go create mode 100644 enums.go delete mode 100644 format/format.go delete mode 100644 fpga_size/fpga_size.go delete mode 100644 fpga_source/fpga_source.go delete mode 100644 gain_mode/gain_mode.go delete mode 100644 io_module/io_module.go delete mode 100644 loopback/loopback.go delete mode 100644 pmic_register/pmic_register.go delete mode 100644 power_source/power_source.go delete mode 100644 rx_mux/rx_mux.go diff --git a/backend/backend.go b/backend/backend.go deleted file mode 100644 index 3cca086..0000000 --- a/backend/backend.go +++ /dev/null @@ -1,14 +0,0 @@ -package backend - -// #include -import "C" - -type Backend int - -const ( - Any Backend = C.BLADERF_BACKEND_ANY - Linux Backend = C.BLADERF_BACKEND_LINUX - LibUSB Backend = C.BLADERF_BACKEND_LIBUSB - Cypress Backend = C.BLADERF_BACKEND_CYPRESS - Dummy Backend = C.BLADERF_BACKEND_DUMMY -) diff --git a/bladerf.go b/bladerf.go index 9cf16a9..78b4319 100644 --- a/bladerf.go +++ b/bladerf.go @@ -11,17 +11,7 @@ import "C" import "C" import ( "fmt" - "github.com/erayarslan/go-bladerf/backend" - "github.com/erayarslan/go-bladerf/channel" - "github.com/erayarslan/go-bladerf/channel_layout" - "github.com/erayarslan/go-bladerf/device_speed" - "github.com/erayarslan/go-bladerf/direction" exception "github.com/erayarslan/go-bladerf/error" - "github.com/erayarslan/go-bladerf/format" - "github.com/erayarslan/go-bladerf/fpga_size" - "github.com/erayarslan/go-bladerf/fpga_source" - "github.com/erayarslan/go-bladerf/gain_mode" - "github.com/erayarslan/go-bladerf/loopback" "github.com/mattn/go-pointer" "unsafe" ) @@ -65,135 +55,198 @@ func LoadFpga(bladeRF BladeRF, imagePath string) error { return GetError(C.bladerf_load_fpga(bladeRF.ref, path)) } -func GetFpgaSize(bladeRF *BladeRF) (fpga_size.FPGASize, error) { +func GetFpgaSize(bladeRF BladeRF) (FpgaSize, error) { var size C.bladerf_fpga_size - err := GetError(C.bladerf_get_fpga_size((*bladeRF).ref, &size)) - return fpga_size.FPGASize(int(size)), err + err := GetError(C.bladerf_get_fpga_size(bladeRF.ref, &size)) + + if err != nil { + return 0, err + } + + return FpgaSize(size), nil } -func GetFpgaSource(bladeRF *BladeRF) (fpga_source.FPGASource, error) { +func GetFpgaSource(bladeRF BladeRF) (FpgaSource, error) { var source C.bladerf_fpga_source - err := GetError(C.bladerf_get_fpga_source((*bladeRF).ref, &source)) - return fpga_source.FPGASource(int(source)), err + err := GetError(C.bladerf_get_fpga_source(bladeRF.ref, &source)) + + if err != nil { + return 0, err + } + + return FpgaSource(source), nil } -func GetFpgaBytes(bladeRF *BladeRF) (uint32, error) { +func GetFpgaBytes(bladeRF BladeRF) (uint32, error) { var size C.size_t - err := GetError(C.bladerf_get_fpga_bytes((*bladeRF).ref, &size)) - return uint32(size), err + err := GetError(C.bladerf_get_fpga_bytes(bladeRF.ref, &size)) + + if err != nil { + return 0, err + } + + return uint32(size), nil } -func GetFpgaFlashSize(bladeRF *BladeRF) (uint32, bool, error) { +func GetFpgaFlashSize(bladeRF BladeRF) (uint32, bool, error) { var size C.uint32_t var isGuess C.bool - err := GetError(C.bladerf_get_flash_size((*bladeRF).ref, &size, &isGuess)) - return uint32(size), bool(isGuess), err + err := GetError(C.bladerf_get_flash_size(bladeRF.ref, &size, &isGuess)) + + if err != nil { + return 0, false, err + } + + return uint32(size), bool(isGuess), nil } -func GetFirmwareVersion(bladeRF *BladeRF) (Version, error) { +func GetFirmwareVersion(bladeRF BladeRF) (Version, error) { var version C.struct_bladerf_version - err := GetError(C.bladerf_fw_version((*bladeRF).ref, &version)) - return NewVersion(&version), err + err := GetError(C.bladerf_fw_version(bladeRF.ref, &version)) + + if err != nil { + return Version{}, err + } + + return NewVersion(&version), nil } -func IsFpgaConfigured(bladeRF *BladeRF) (bool, error) { - out := C.bladerf_is_fpga_configured((*bladeRF).ref) - if int(out) < 0 { +func IsFpgaConfigured(bladeRF BladeRF) (bool, error) { + out := C.bladerf_is_fpga_configured(bladeRF.ref) + + if out < 0 { return false, GetError(out) } - return int(out) == 1, nil + return out == 1, nil } -func GetDeviceSpeed(bladeRF *BladeRF) device_speed.DeviceSpeed { - return device_speed.DeviceSpeed(int(C.bladerf_device_speed((*bladeRF).ref))) +func GetDeviceSpeed(bladeRF BladeRF) DeviceSpeed { + return DeviceSpeed(int(C.bladerf_device_speed(bladeRF.ref))) } -func GetFpgaVersion(bladeRF *BladeRF) (Version, error) { +func GetFpgaVersion(bladeRF BladeRF) (Version, error) { var version C.struct_bladerf_version - err := GetError(C.bladerf_fpga_version((*bladeRF).ref, &version)) - return NewVersion(&version), err + err := GetError(C.bladerf_fpga_version(bladeRF.ref, &version)) + + if err != nil { + return Version{}, err + } + + return NewVersion(&version), nil } -func FreeDeviceList(devInfo DevInfo) { - C.bladerf_free_device_list(devInfo.ref) +func FreeDeviceList(deviceInfo DeviceInfo) { + C.bladerf_free_device_list(deviceInfo.ref) } -func GetDeviceList() []DevInfo { - var devInfo *C.struct_bladerf_devinfo - var devices []DevInfo +func GetDeviceList() ([]DeviceInfo, error) { + var deviceInfo *C.struct_bladerf_devinfo + var devices []DeviceInfo - count := int(C.bladerf_get_device_list(&devInfo)) + codeOrCount := C.bladerf_get_device_list(&deviceInfo) + + if codeOrCount < 0 { + return nil, GetError(codeOrCount) + } + + count := int(codeOrCount) + + if count == 0 { + return make([]DeviceInfo, 0), nil + } if count > 0 { - size := unsafe.Sizeof(*devInfo) + size := unsafe.Sizeof(*deviceInfo) for i := 0; i < count; i++ { - devices = append(devices, NewDevInfo( - (*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(devInfo))+(uintptr(i)*size))), + devices = append(devices, NewDeviceInfo( + (*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(deviceInfo))+(uintptr(i)*size))), )) } FreeDeviceList(devices[0]) } - return devices + return devices, nil } -func GetBootloaderList() []DevInfo { - var devInfo *C.struct_bladerf_devinfo - var devices []DevInfo +func GetBootloaderList() ([]DeviceInfo, error) { + var deviceInfo *C.struct_bladerf_devinfo + var devices []DeviceInfo - count := int(C.bladerf_get_bootloader_list(&devInfo)) + codeOrCount := C.bladerf_get_bootloader_list(&deviceInfo) + + if codeOrCount < 0 { + return nil, GetError(codeOrCount) + } + + count := int(codeOrCount) + + if count == 0 { + return make([]DeviceInfo, 0), nil + } if count > 0 { - size := unsafe.Sizeof(*devInfo) + size := unsafe.Sizeof(*deviceInfo) for i := 0; i < count; i++ { - devices = append(devices, NewDevInfo( - (*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(devInfo))+(uintptr(i)*size))), + devices = append(devices, NewDeviceInfo( + (*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(deviceInfo))+(uintptr(i)*size))), )) } FreeDeviceList(devices[0]) } - return devices + return devices, nil } -func InitDevInfo() DevInfo { - var devInfo C.struct_bladerf_devinfo - C.bladerf_init_devinfo(&devInfo) - return NewDevInfo(&devInfo) +func InitDeviceInfo() DeviceInfo { + var deviceInfo C.struct_bladerf_devinfo + C.bladerf_init_devinfo(&deviceInfo) + return NewDeviceInfo(&deviceInfo) } -func GetDevInfo(bladeRF *BladeRF) DevInfo { - var devInfo C.struct_bladerf_devinfo - C.bladerf_get_devinfo((*bladeRF).ref, &devInfo) - return NewDevInfo(&devInfo) +func GetDeviceInfo(bladeRF BladeRF) (DeviceInfo, error) { + var deviceInfo C.struct_bladerf_devinfo + err := GetError(C.bladerf_get_devinfo(bladeRF.ref, &deviceInfo)) + + if err != nil { + return DeviceInfo{}, err + } + + return NewDeviceInfo(&deviceInfo), nil } -func DevInfoMatches(a DevInfo, b DevInfo) bool { +func DeviceInfoMatches(a DeviceInfo, b DeviceInfo) bool { return bool(C.bladerf_devinfo_matches(a.ref, b.ref)) } -func DevStrMatches(devStr string, info DevInfo) bool { - val := C.CString(devStr) +func DeviceStringMatches(deviceString string, deviceInfo DeviceInfo) bool { + val := C.CString(deviceString) defer C.free(unsafe.Pointer(val)) - return bool(C.bladerf_devstr_matches(val, info.ref)) + + return bool(C.bladerf_devstr_matches(val, deviceInfo.ref)) } -func GetDevInfoFromStr(devStr string) DevInfo { - val := C.CString(devStr) +func GetDeviceInfoFromString(deviceString string) (DeviceInfo, error) { + val := C.CString(deviceString) defer C.free(unsafe.Pointer(val)) - var devInfo C.struct_bladerf_devinfo - C.bladerf_get_devinfo_from_str(val, &devInfo) - return NewDevInfo(&devInfo) + + var deviceInfo C.struct_bladerf_devinfo + err := GetError(C.bladerf_get_devinfo_from_str(val, &deviceInfo)) + + if err != nil { + return DeviceInfo{}, err + } + + return NewDeviceInfo(&deviceInfo), nil } -func OpenWithDevInfo(devInfo DevInfo) (BladeRF, error) { +func OpenWithDeviceInfo(deviceInfo DeviceInfo) (BladeRF, error) { var bladeRF *C.struct_bladerf - err := GetError(C.bladerf_open_with_devinfo(&bladeRF, devInfo.ref)) + err := GetError(C.bladerf_open_with_devinfo(&bladeRF, deviceInfo.ref)) if err != nil { return BladeRF{}, err @@ -202,46 +255,66 @@ func OpenWithDevInfo(devInfo DevInfo) (BladeRF, error) { return BladeRF{ref: bladeRF}, nil } -func OpenWithDeviceIdentifier(identify string) BladeRF { +func OpenWithDeviceIdentifier(identify string) (BladeRF, error) { var bladeRF *C.struct_bladerf - C.bladerf_open(&bladeRF, C.CString(identify)) - return BladeRF{ref: bladeRF} + err := GetError(C.bladerf_open(&bladeRF, C.CString(identify))) + + if err != nil { + return BladeRF{}, err + } + + return BladeRF{ref: bladeRF}, nil } -func Open() BladeRF { +func Open() (BladeRF, error) { var bladeRF *C.struct_bladerf - C.bladerf_open(&bladeRF, nil) - return BladeRF{ref: bladeRF} + err := GetError(C.bladerf_open(&bladeRF, nil)) + + if err != nil { + return BladeRF{}, err + } + + return BladeRF{ref: bladeRF}, nil } func Close(bladeRF BladeRF) { C.bladerf_close(bladeRF.ref) } -func SetLoopback(bladeRF *BladeRF, loopback loopback.Loopback) error { - return GetError(C.bladerf_set_loopback((*bladeRF).ref, C.bladerf_loopback(loopback))) +func SetLoopback(bladeRF BladeRF, loopback Loopback) error { + return GetError(C.bladerf_set_loopback(bladeRF.ref, C.bladerf_loopback(loopback))) } -func SetFrequency(bladeRF *BladeRF, channel channel.Channel, frequency int) error { - return GetError(C.bladerf_set_frequency((*bladeRF).ref, C.bladerf_channel(channel), C.bladerf_frequency(frequency))) +func SetFrequency(bladeRF BladeRF, channel Channel, frequency uint64) error { + return GetError(C.bladerf_set_frequency(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_frequency(frequency))) } -func SetSampleRate(bladeRF *BladeRF, channel channel.Channel, sampleRate int) error { +func SetSampleRate(bladeRF BladeRF, channel Channel, sampleRate uint) (uint, error) { var actual C.uint - err := GetError(C.bladerf_set_sample_rate((*bladeRF).ref, C.bladerf_channel(channel), C.uint(sampleRate), &actual)) - return err + 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 + } + + return uint(actual), err } -func GetRationalSampleRate(bladeRF *BladeRF, channel channel.Channel) (RationalRate, error) { +func GetRationalSampleRate(bladeRF BladeRF, 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)) - return NewRationalRate(&rate), err + err := GetError(C.bladerf_get_rational_sample_rate(bladeRF.ref, C.bladerf_channel(channel), &rate)) + + if err != nil { + return RationalRate{}, err + } + + return NewRationalRate(&rate), nil } -func GetSampleRateRange(bladeRF *BladeRF, channel channel.Channel) (int, int, int, error) { +func GetSampleRateRange(bladeRF BladeRF, channel Channel) (int, int, int, error) { var bfRange *C.struct_bladerf_range - err := GetError(C.bladerf_get_sample_rate_range((*bladeRF).ref, C.bladerf_channel(channel), &bfRange)) + err := GetError(C.bladerf_get_sample_rate_range(bladeRF.ref, C.bladerf_channel(channel), &bfRange)) if err != nil { return 0, 0, 0, err @@ -250,138 +323,173 @@ func GetSampleRateRange(bladeRF *BladeRF, channel channel.Channel) (int, int, in return int(bfRange.min), int(bfRange.max), int(bfRange.step), nil } -func SetBandwidth(bladeRF *BladeRF, channel channel.Channel, bandwidth int) (int, error) { +func SetBandwidth(bladeRF BladeRF, channel Channel, bandwidth uint) (uint, error) { var actual C.bladerf_bandwidth - return int(actual), GetError(C.bladerf_set_bandwidth((*bladeRF).ref, C.bladerf_channel(channel), C.uint(bandwidth), &actual)) -} + err := GetError(C.bladerf_set_bandwidth(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_bandwidth(bandwidth), &actual)) -func SetGain(bladeRF *BladeRF, channel channel.Channel, gain int) error { - return GetError(C.bladerf_set_gain((*bladeRF).ref, C.bladerf_channel(channel), C.int(gain))) -} - -func GetGain(bladeRF *BladeRF, channel channel.Channel) (int, error) { - var gain C.bladerf_gain - err := GetError(C.bladerf_get_gain((*bladeRF).ref, C.bladerf_channel(channel), &gain)) - if err == nil { - return int(gain), nil + if err != nil { + return 0, err } - return int(gain), err + return uint(actual), nil } -func GetGainStage(bladeRF *BladeRF, channel channel.Channel, stage string) (int, error) { +func SetGain(bladeRF BladeRF, 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) { + var gain C.bladerf_gain + err := GetError(C.bladerf_get_gain(bladeRF.ref, C.bladerf_channel(channel), &gain)) + + if err != nil { + return 0, err + } + + return int(gain), nil +} + +func GetGainStage(bladeRF BladeRF, channel Channel, stage string) (int, error) { val := C.CString(stage) defer C.free(unsafe.Pointer(val)) + var gain C.bladerf_gain - err := GetError(C.bladerf_get_gain_stage((*bladeRF).ref, C.bladerf_channel(channel), val, &gain)) - if err == nil { - return int(gain), nil + err := GetError(C.bladerf_get_gain_stage(bladeRF.ref, C.bladerf_channel(channel), val, &gain)) + + if err != nil { + return 0, err } - return int(gain), err + return int(gain), nil } -func GetGainMode(bladeRF *BladeRF, channel channel.Channel) (gain_mode.GainMode, error) { +func GetGainMode(bladeRF BladeRF, channel Channel) (GainMode, error) { var mode C.bladerf_gain_mode - err := GetError(C.bladerf_get_gain_mode((*bladeRF).ref, C.bladerf_channel(channel), &mode)) - result := gain_mode.GainMode(int(mode)) - if err == nil { - return result, nil + err := GetError(C.bladerf_get_gain_mode(bladeRF.ref, C.bladerf_channel(channel), &mode)) + + if err != nil { + return 0, err } - return result, err + return GainMode(mode), nil } -func SetGainStage(bladeRF *BladeRF, channel 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.int(gain))) -} - -func GetGainStageRange(bladeRF *BladeRF, channel channel.Channel, stage string) (Range, error) { - var bfRange *C.struct_bladerf_range +func SetGainStage(bladeRF BladeRF, channel Channel, stage string, gain int) error { val := C.CString(stage) defer C.free(unsafe.Pointer(val)) - err := GetError(C.bladerf_get_gain_stage_range((*bladeRF).ref, C.bladerf_channel(channel), val, &bfRange)) - - if err == nil { - return Range{ - ref: bfRange, - min: int64(bfRange.min), - max: int64(bfRange.max), - step: int64(bfRange.step), - scale: float64(bfRange.scale), - }, nil - } - - return Range{}, err + return GetError(C.bladerf_set_gain_stage(bladeRF.ref, C.bladerf_channel(channel), val, C.bladerf_gain(gain))) } -func GetGainRange(bladeRF *BladeRF, channel channel.Channel) (Range, error) { +func GetGainStageRange(bladeRF BladeRF, channel Channel, stage string) (Range, error) { + val := C.CString(stage) + defer C.free(unsafe.Pointer(val)) + var bfRange *C.struct_bladerf_range + err := GetError(C.bladerf_get_gain_stage_range(bladeRF.ref, C.bladerf_channel(channel), val, &bfRange)) - err := GetError(C.bladerf_get_gain_range((*bladeRF).ref, C.bladerf_channel(channel), &bfRange)) - - if err == nil { - return Range{ - ref: bfRange, - min: int64(bfRange.min), - max: int64(bfRange.max), - step: int64(bfRange.step), - scale: float64(bfRange.scale), - }, nil + if err != nil { + return Range{}, err } - return Range{}, err + return Range{ + ref: bfRange, + min: int64(bfRange.min), + max: int64(bfRange.max), + step: int64(bfRange.step), + scale: float64(bfRange.scale), + }, nil } -func GetNumberOfGainStages(bladeRF *BladeRF, channel channel.Channel) int { - count := int(C.bladerf_get_gain_stages((*bladeRF).ref, C.bladerf_channel(channel), nil, 0)) +func GetGainRange(bladeRF BladeRF, channel Channel) (Range, error) { + var bfRange *C.struct_bladerf_range + err := GetError(C.bladerf_get_gain_range(bladeRF.ref, C.bladerf_channel(channel), &bfRange)) - if count < 1 { - return 0 + if err != nil { + return Range{}, err } - return count + return Range{ + ref: bfRange, + min: int64(bfRange.min), + max: int64(bfRange.max), + step: int64(bfRange.step), + scale: float64(bfRange.scale), + }, nil } -func BackendSTR(backend backend.Backend) string { +func GetNumberOfGainStages(bladeRF BladeRF, channel Channel) (int, error) { + countOrCode := C.bladerf_get_gain_stages(bladeRF.ref, C.bladerf_channel(channel), nil, 0) + + if countOrCode < 0 { + return 0, GetError(countOrCode) + } + + return int(countOrCode), nil +} + +func BackendString(backend Backend) string { return C.GoString(C.bladerf_backend_str(C.bladerf_backend(backend))) } -func GetBoardName(bladeRF *BladeRF) string { - return C.GoString(C.bladerf_get_board_name((*bladeRF).ref)) +func GetBoardName(bladeRF BladeRF) string { + return C.GoString(C.bladerf_get_board_name(bladeRF.ref)) } func SetUSBResetOnOpen(enabled bool) { C.bladerf_set_usb_reset_on_open(C.bool(enabled)) } -func GetSerial(bladeRF *BladeRF) (string, error) { +func GetSerial(bladeRF BladeRF) (string, error) { var serial C.char - GetError(C.bladerf_get_serial((*bladeRF).ref, &serial)) + err := GetError(C.bladerf_get_serial(bladeRF.ref, &serial)) + + if err != nil { + return "", err + } + return C.GoString(&serial), nil } -func GetSerialStruct(bladeRF *BladeRF) (Serial, error) { +func GetSerialStruct(bladeRF BladeRF) (Serial, error) { var serial C.struct_bladerf_serial - GetError(C.bladerf_get_serial_struct((*bladeRF).ref, &serial)) + err := GetError(C.bladerf_get_serial_struct(bladeRF.ref, &serial)) + + if err != nil { + return Serial{}, err + } + return NewSerial(&serial), nil } -func GetGainStages(bladeRF *BladeRF, channel channel.Channel) []string { +func GetGainStages(bladeRF BladeRF, channel Channel) ([]string, error) { var stage *C.char var stages []string - count := int(C.bladerf_get_gain_stages( - (*bladeRF).ref, + numberOfGainStages, err := GetNumberOfGainStages(bladeRF, channel) + + if err != nil { + return nil, err + } + + countOrCode := C.bladerf_get_gain_stages( + bladeRF.ref, C.bladerf_channel(channel), &stage, - C.ulong(GetNumberOfGainStages(bladeRF, channel))), + C.ulong(numberOfGainStages), ) + if countOrCode < 0 { + return nil, GetError(countOrCode) + } + + if countOrCode == 0 { + return make([]string, 0), nil + } + + count := int(countOrCode) + if count > 0 { size := unsafe.Sizeof(*stage) @@ -392,14 +500,24 @@ func GetGainStages(bladeRF *BladeRF, channel channel.Channel) []string { } } - return stages + return stages, nil } -func GetGainModes(bladeRF *BladeRF, channel channel.Channel) []GainModes { +func GetGainModes(bladeRF BladeRF, channel Channel) ([]GainModes, error) { var gainMode *C.struct_bladerf_gain_modes var gainModes []GainModes - count := int(C.bladerf_get_gain_modes((*bladeRF).ref, C.bladerf_channel(channel), &gainMode)) + countOrCode := C.bladerf_get_gain_modes(bladeRF.ref, C.bladerf_channel(channel), &gainMode) + + if countOrCode < 0 { + return nil, GetError(countOrCode) + } + + if countOrCode == 0 { + return make([]GainModes, 0), nil + } + + count := int(countOrCode) if count > 0 { size := unsafe.Sizeof(*gainMode) @@ -411,52 +529,51 @@ func GetGainModes(bladeRF *BladeRF, channel channel.Channel) []GainModes { } } - return gainModes + return gainModes, nil } -func SetGainMode(bladeRF *BladeRF, channel channel.Channel, mode gain_mode.GainMode) error { - return GetError(C.bladerf_set_gain_mode((*bladeRF).ref, C.bladerf_channel(channel), C.bladerf_gain_mode(mode))) +func SetGainMode(bladeRF BladeRF, 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.Channel) error { - return GetError(C.bladerf_enable_module((*bladeRF).ref, C.bladerf_channel(channel), true)) +func EnableModule(bladeRF BladeRF, channel Channel) error { + return GetError(C.bladerf_enable_module(bladeRF.ref, C.bladerf_channel(channel), true)) } -func DisableModule(bladeRF *BladeRF, channel channel.Channel) error { - return GetError(C.bladerf_enable_module((*bladeRF).ref, C.bladerf_channel(channel), false)) +func DisableModule(bladeRF BladeRF, channel Channel) error { + return GetError(C.bladerf_enable_module(bladeRF.ref, C.bladerf_channel(channel), false)) } -func SyncRX(bladeRF *BladeRF, bufferSize uintptr) ([]int16, error) { +func SyncRX(bladeRF BladeRF, 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)) - var err error - var results []int16 - - err = GetError(C.bladerf_sync_rx((*bladeRF).ref, start, C.uint(bufferSize), &metadata, 32)) - - if err == nil { - for i := 0; i < (int(metadata.actual_count)); i++ { - n := (*C.int16_t)(unsafe.Pointer(uintptr(start) + (C.sizeof_int16_t * uintptr(i)))) - results = append(results, int16(*n)) - } - - return results, nil + if err != nil { + return nil, err } - return nil, err + var results []int16 + + for i := 0; i < (int(metadata.actual_count)); i++ { + n := (*C.int16_t)(unsafe.Pointer(uintptr(start) + (C.sizeof_int16_t * uintptr(i)))) + results = append(results, int16(*n)) + } + + return results, nil } -func InitStream(bladeRF *BladeRF, format format.Format, numBuffers int, samplesPerBuffer int, numTransfers int, callback func(data []int16)) *Stream { +func InitStream(bladeRF BladeRF, + format Format, + numBuffers int, samplesPerBuffer int, numTransfers int, callback func(data []int16)) (Stream, error) { var buffers *unsafe.Pointer var rxStream *C.struct_bladerf_stream stream := Stream{ref: rxStream} - C.bladerf_init_stream( + err := GetError(C.bladerf_init_stream( &((stream).ref), - (*bladeRF).ref, + bladeRF.ref, (*[0]byte)((C.StreamCallback)), &buffers, C.ulong(numBuffers), @@ -464,29 +581,38 @@ func InitStream(bladeRF *BladeRF, format format.Format, numBuffers int, samplesP C.ulong(samplesPerBuffer), C.ulong(numTransfers), pointer.Save(NewUserData(callback, samplesPerBuffer)), - ) + )) - return &stream + if err != nil { + return Stream{}, err + } + + return stream, nil } -func DeInitStream(stream *Stream) { +func DeInitStream(stream Stream) { C.bladerf_deinit_stream(stream.ref) } -func GetStreamTimeout(bladeRF *BladeRF, direction direction.Direction) (int, error) { +func GetStreamTimeout(bladeRF BladeRF, direction Direction) (uint, error) { var timeout C.uint - err := GetError(C.bladerf_get_stream_timeout((*bladeRF).ref, C.bladerf_direction(direction), &timeout)) - return int(timeout), err + err := GetError(C.bladerf_get_stream_timeout(bladeRF.ref, C.bladerf_direction(direction), &timeout)) + + if err != nil { + return 0, err + } + + return uint(timeout), err } -func SetStreamTimeout(bladeRF *BladeRF, direction direction.Direction, timeout int) error { - return GetError(C.bladerf_set_stream_timeout((*bladeRF).ref, C.bladerf_direction(direction), C.uint(timeout))) +func SetStreamTimeout(bladeRF BladeRF, 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 channel_layout.ChannelLayout, format format.Format, numBuffers int, bufferSize int, numTransfers int, timeout int) 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 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 StartStream(stream *Stream, layout channel_layout.ChannelLayout) error { +func StartStream(stream Stream, layout ChannelLayout) error { return GetError(C.bladerf_stream(stream.ref, C.bladerf_channel_layout(layout))) } diff --git a/bladerf_test.go b/bladerf_test.go index 6e72a5e..df613ec 100644 --- a/bladerf_test.go +++ b/bladerf_test.go @@ -2,11 +2,6 @@ package bladerf import ( "fmt" - "github.com/erayarslan/go-bladerf/backend" - "github.com/erayarslan/go-bladerf/channel_layout" - "github.com/erayarslan/go-bladerf/direction" - "github.com/erayarslan/go-bladerf/format" - "github.com/erayarslan/go-bladerf/gain_mode" "github.com/erayarslan/go-bladerf/log" "github.com/gordonklaus/portaudio" fifo "github.com/racerxdl/go.fifo" @@ -61,11 +56,11 @@ func GetFinalDataString(input []int16) string { } func TestBackendSTR(t *testing.T) { - x := BackendSTR(backend.LibUSB) - y := BackendSTR(backend.Dummy) - z := BackendSTR(backend.Any) - a := BackendSTR(backend.Cypress) - b := BackendSTR(backend.Linux) + x := BackendString(BackendLibUSB) + y := BackendString(BackendDummy) + z := BackendString(BackendAny) + a := BackendString(BackendCypress) + b := BackendString(BackendLinux) fmt.Println(x, y, z, a, b) } @@ -77,205 +72,220 @@ func TestSetUSBResetOnOpen(t *testing.T) { func TestGetSerial(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - serial, _ := GetSerial(&rf) + serial, _ := GetSerial(rf) fmt.Println(serial) } func TestGetSerialStruct(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - serial, _ := GetSerialStruct(&rf) + serial, _ := GetSerialStruct(rf) fmt.Print(serial) } func TestGetFpgaSize(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - size, _ := GetFpgaSize(&rf) + size, _ := GetFpgaSize(rf) fmt.Print(size) } func TestGetFpgaSource(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - source, _ := GetFpgaSource(&rf) + source, _ := GetFpgaSource(rf) fmt.Print(source) } func TestGetDeviceSpeed(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - speed := GetDeviceSpeed(&rf) + speed := GetDeviceSpeed(rf) fmt.Print(speed) } func TestGetBoardName(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - name := GetBoardName(&rf) + name := GetBoardName(rf) fmt.Print(name) } func TestGetRationalSampleRate(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - rate, _ := GetRationalSampleRate(&rf, CHANNEL_RX(1)) + rate, _ := GetRationalSampleRate(rf, ChannelRx(1)) fmt.Print(rate) } func TestGetFpgaBytes(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - bytes, _ := GetFpgaBytes(&rf) + bytes, _ := GetFpgaBytes(rf) fmt.Print(bytes) } func TestGetFpgaFlashSize(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - size, guess, _ := GetFpgaFlashSize(&rf) - fmt.Print(size) - fmt.Print(guess) + size, guess, err := GetFpgaFlashSize(rf) + + if err != nil { + panic(err) + } else { + fmt.Print(size) + fmt.Print(guess) + } } func TestGetFirmwareVersion(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - version, _ := GetFirmwareVersion(&rf) + version, err := GetFirmwareVersion(rf) + + if err != nil { + panic(err) + } + fmt.Print(version.describe) } func TestGetFpgaVersion(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - version, _ := GetFpgaVersion(&rf) + version, _ := GetFpgaVersion(rf) fmt.Print(version.describe) } func TestIsFpgaConfigured(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - isConfigured, _ := IsFpgaConfigured(&rf) + isConfigured, err := IsFpgaConfigured(rf) + + if err != nil { + panic(err) + } + fmt.Print(isConfigured) } @@ -284,63 +294,69 @@ func TestBladeRF(t *testing.T) { PrintVersion(GetVersion()) - bootloaders := GetBootloaderList() + bootloaders, _ := GetBootloaderList() fmt.Printf("Bootloaders Len: %d\n", len(bootloaders)) - devices := GetDeviceList() + devices, _ := GetDeviceList() fmt.Printf("Devices Len: %d\n", len(devices)) - rf, _ := OpenWithDevInfo(devices[0]) - LoadFpga(rf, "/Users/erayarslan/Downloads/hostedxA4-latest.rbf") + rf, _ := OpenWithDeviceInfo(devices[0]) + _ = LoadFpga(rf, "/Users/erayarslan/Downloads/hostedxA4-latest.rbf") Close(rf) - rf = Open() - info := GetDevInfo(&rf) + rf, _ = Open() + info, _ := GetDeviceInfo(rf) Close(rf) - out, _ := OpenWithDevInfo(GetDevInfo(&rf)) + h, _ := GetDeviceInfo(rf) + out, _ := OpenWithDeviceInfo(h) Close(out) - Close(Open()) - Close(OpenWithDeviceIdentifier("*:serial=" + info.serial)) - out2, _ := OpenWithDevInfo(GetDevInfoFromStr("*:serial=" + info.serial)) + c1, _ := Open() + Close(c1) + c2, _ := OpenWithDeviceIdentifier("*:serial=" + info.serial) + Close(c2) + o1, _ := GetDeviceInfoFromString("*:serial=" + info.serial) + out2, _ := OpenWithDeviceInfo(o1) Close(out2) - result := DevInfoMatches(GetDevInfo(&rf), GetDevInfo(&rf)) + g, _ := GetDeviceInfo(rf) + result := DeviceInfoMatches(g, g) fmt.Println("---------") fmt.Println(result) fmt.Println("---------") - result = DevStrMatches("*:serial="+info.serial, GetDevInfo(&rf)) + g0, _ := GetDeviceInfo(rf) + result = DeviceStringMatches("*:serial="+info.serial, g0) fmt.Println("---------") fmt.Println(result) fmt.Println("---------") - rf = Open() + rf, _ = Open() - err := EnableModule(&rf, CHANNEL_RX(1)) + err := EnableModule(rf, ChannelRx(1)) if err != nil { fmt.Println(err) } - _ = InitStream(&rf, format.SC16_Q11, 16, audioBufferSize, 8, cb) + _, _ = InitStream(rf, FormatSc16Q11, 16, audioBufferSize, 8, cb) // _ = StartStream(stream, RX_X1) } func TestSetGainStage(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - stages := GetGainStages(&rf, CHANNEL_RX(1)) + stages, _ := GetGainStages(rf, ChannelRx(1)) fmt.Println(len(stages)) - bfRange, _ := GetGainStageRange(&rf, CHANNEL_RX(1), stages[0]) - _ = SetGainStage(&rf, CHANNEL_RX(1), stages[0], int(bfRange.max)) - gain, _ := GetGainStage(&rf, CHANNEL_RX(1), stages[0]) + bfRange, _ := GetGainStageRange(rf, ChannelRx(1), stages[0]) + _ = SetGainStage(rf, ChannelRx(1), stages[0], int(bfRange.max)) + gain, _ := GetGainStage(rf, ChannelRx(1), stages[0]) fmt.Println(gain) } @@ -350,30 +366,30 @@ func TestStream(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() - channel := CHANNEL_RX(1) + devices, _ := GetDeviceList() + channel := ChannelRx(1) if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - _ = SetFrequency(&rf, channel, 96600000) - min, max, step, _ := GetSampleRateRange(&rf, channel) + _ = SetFrequency(rf, channel, 96600000) + min, max, step, _ := GetSampleRateRange(rf, channel) fmt.Printf("Min: %d, Max: %d, Step: %d\n", min, max, step) - _ = SetSampleRate(&rf, channel, 4e6) - _ = SyncConfig(&rf, channel_layout.RX_X2, format.SC16_Q11, 16, audioBufferSize, 8, 32) - actual, _ := SetBandwidth(&rf, channel, 240000) + _, _ = SetSampleRate(rf, channel, 4e6) + _ = SyncConfig(rf, RxX2, FormatSc16Q11, 16, audioBufferSize, 8, 32) + actual, _ := SetBandwidth(rf, channel, 240000) fmt.Println(actual) - _ = EnableModule(&rf, channel) - _ = SetGainMode(&rf, channel, gain_mode.Hybrid_AGC) + _ = EnableModule(rf, channel) + _ = SetGainMode(rf, channel, GainModeHybridAgc) demodulator = demodcore.MakeWBFMDemodulator(uint32(2e6), 80e3, 48000) - portaudio.Initialize() + _ = portaudio.Initialize() h, _ := portaudio.DefaultHostApi() p := portaudio.LowLatencyParameters(nil, h.DefaultOutputDevice) @@ -387,7 +403,7 @@ func TestStream(t *testing.T) { go func() { for { - data, _ := SyncRX(&rf, audioBufferSize) + data, _ := SyncRX(rf, audioBufferSize) out := demodulator.Work(GetFinalData(data)) if out != nil { @@ -423,59 +439,59 @@ func cb(data []int16) { func TestGetGainModes(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - GetGainModes(&rf, CHANNEL_RX(1)) + _, _ = GetGainModes(rf, ChannelRx(1)) } func TestGetGainRange(t *testing.T) { log.SetVerbosity(log.Debug) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - bfRange, _ := GetGainRange(&rf, CHANNEL_RX(1)) + bfRange, _ := GetGainRange(rf, ChannelRx(1)) fmt.Println(bfRange.max) } func TestGPSData(t *testing.T) { log.SetVerbosity(log.Debug) - channel := CHANNEL_RX(1) + channel := ChannelRx(1) - devices := GetDeviceList() + devices, _ := GetDeviceList() if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, _ := OpenWithDeviceInfo(devices[0]) defer Close(rf) - _ = SetFrequency(&rf, channel, 1525420000) - _ = SyncConfig(&rf, channel_layout.RX_X2, format.SC16_Q11, 16, audioBufferSize, 8, 32) - _ = SetSampleRate(&rf, channel, 2600000) - _, _ = SetBandwidth(&rf, channel, 2500000) - //_ = SetGainMode(&rf, channel, Hybrid_AGC) - _ = EnableModule(&rf, channel) + _ = 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) for { - data, _ := SyncRX(&rf, audioBufferSize) + data, _ := SyncRX(rf, audioBufferSize) out := GetFinalDataString(data) fmt.Println(out) } @@ -487,34 +503,46 @@ func TestAsyncStream(t *testing.T) { sig := make(chan os.Signal, 1) signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill) - channel := CHANNEL_RX(0) + channel := ChannelRx(0) - devices := GetDeviceList() + devices, err := GetDeviceList() + + if err != nil { + panic(err) + } if len(devices) == 0 { fmt.Println("NO DEVICE") return } - rf, _ := OpenWithDevInfo(devices[0]) + rf, err := OpenWithDeviceInfo(devices[0]) + + if err != nil { + panic(err) + } + defer Close(rf) - _ = SetFrequency(&rf, channel, 96600000) - _ = SetSampleRate(&rf, channel, 4e6) - _, _ = SetBandwidth(&rf, channel, 240000) - //_ = SetGainMode(&rf, channel, Hybrid_AGC) - _ = EnableModule(&rf, channel) + _ = SetFrequency(rf, channel, 96600000) + _, _ = SetSampleRate(rf, channel, 4e6) + _, _ = SetBandwidth(rf, channel, 240000) + _ = SetGainMode(rf, channel, GainModeHybridAgc) + _ = EnableModule(rf, channel) - rxStream := InitStream(&rf, format.SC16_Q11, 16, audioBufferSize, 8, cb) + rxStream, err := InitStream(rf, FormatSc16Q11, 16, audioBufferSize, 8, cb) + if err != nil { + panic(err) + } defer DeInitStream(rxStream) - _ = SetStreamTimeout(&rf, direction.RX, 32) - timeout, _ := GetStreamTimeout(&rf, direction.RX) + _ = SetStreamTimeout(rf, Rx, 32) + timeout, _ := GetStreamTimeout(rf, Rx) println(timeout) demodulator = demodcore.MakeWBFMDemodulator(uint32(2e6), 80e3, 48000) - portaudio.Initialize() + _ = portaudio.Initialize() h, _ := portaudio.DefaultHostApi() p := portaudio.LowLatencyParameters(nil, h.DefaultOutputDevice) @@ -527,9 +555,12 @@ func TestAsyncStream(t *testing.T) { _ = audioStream.Start() go func() { - _ = StartStream(rxStream, channel_layout.RX_X2) + err = StartStream(rxStream, RxX2) + if err != nil { + panic(err) + } }() <-sig - fmt.Println("hehe") + fmt.Println("done") } diff --git a/channel/channel.go b/channel/channel.go deleted file mode 100644 index e9feb20..0000000 --- a/channel/channel.go +++ /dev/null @@ -1,3 +0,0 @@ -package channel - -type Channel int diff --git a/channel_layout/channel_layout.go b/channel_layout/channel_layout.go deleted file mode 100644 index eecc57e..0000000 --- a/channel_layout/channel_layout.go +++ /dev/null @@ -1,13 +0,0 @@ -package channel_layout - -// #include -import "C" - -type ChannelLayout int - -const ( - RX_X1 ChannelLayout = C.BLADERF_RX_X1 - TX_X1 ChannelLayout = C.BLADERF_TX_X1 - RX_X2 ChannelLayout = C.BLADERF_RX_X2 - TX_X2 ChannelLayout = C.BLADERF_TX_X2 -) diff --git a/clock_select/clock_select.go b/clock_select/clock_select.go deleted file mode 100644 index 88c02e3..0000000 --- a/clock_select/clock_select.go +++ /dev/null @@ -1,12 +0,0 @@ -package clock_select - -// #include -import "C" - -type ClockSelect int - -const ( - ClockSelectUnknown ClockSelect = -99 - ClockSelectVCTCXO ClockSelect = C.CLOCK_SELECT_ONBOARD - ClockSelectExternal ClockSelect = C.CLOCK_SELECT_EXTERNAL -) diff --git a/correction/correction.go b/correction/correction.go deleted file mode 100644 index a1ed84e..0000000 --- a/correction/correction.go +++ /dev/null @@ -1,13 +0,0 @@ -package channel_layout - -// #include -import "C" - -type Correction int - -const ( - DCOFF_I Correction = C.BLADERF_CORR_DCOFF_I - DCOFF_Q Correction = C.BLADERF_CORR_DCOFF_Q - PHASE Correction = C.BLADERF_CORR_PHASE - GAIN Correction = C.BLADERF_CORR_GAIN -) diff --git a/device_speed/device_speed.go b/device_speed/device_speed.go deleted file mode 100644 index 73fc262..0000000 --- a/device_speed/device_speed.go +++ /dev/null @@ -1,12 +0,0 @@ -package device_speed - -// #include -import "C" - -type DeviceSpeed int - -const ( - SpeedUnknown DeviceSpeed = C.BLADERF_DEVICE_SPEED_UNKNOWN - SpeedHigh DeviceSpeed = C.BLADERF_DEVICE_SPEED_HIGH - SpeedSuper DeviceSpeed = C.BLADERF_DEVICE_SPEED_SUPER -) diff --git a/direction/direction.go b/direction/direction.go deleted file mode 100644 index cda75e6..0000000 --- a/direction/direction.go +++ /dev/null @@ -1,11 +0,0 @@ -package direction - -// #include -import "C" - -type Direction int - -const ( - TX Direction = C.BLADERF_TX - RX Direction = C.BLADERF_RX -) diff --git a/enums.go b/enums.go new file mode 100644 index 0000000..a733c4d --- /dev/null +++ b/enums.go @@ -0,0 +1,126 @@ +package bladerf + +// #include +import "C" + +type Backend int +type Channel int +type ChannelLayout int +type ClockSelect int +type Correction int +type Direction int +type DeviceSpeed int +type Format int +type FpgaSize int +type FpgaSource int +type GainMode int +type Module int +type Loopback int +type PmicRegister int +type PowerSource int +type RxMux int + +const ( + BackendAny Backend = C.BLADERF_BACKEND_ANY + BackendLinux Backend = C.BLADERF_BACKEND_LINUX + BackendLibUSB Backend = C.BLADERF_BACKEND_LIBUSB + BackendCypress Backend = C.BLADERF_BACKEND_CYPRESS + BackendDummy Backend = C.BLADERF_BACKEND_DUMMY +) + +const ( + RxX1 ChannelLayout = C.BLADERF_RX_X1 + TxX1 ChannelLayout = C.BLADERF_TX_X1 + RxX2 ChannelLayout = C.BLADERF_RX_X2 + TxX2 ChannelLayout = C.BLADERF_TX_X2 +) + +const ( + ClockSelectOnboard ClockSelect = C.CLOCK_SELECT_ONBOARD + ClockSelectExternal ClockSelect = C.CLOCK_SELECT_EXTERNAL +) +const ( + CorrectionDcoffI Correction = C.BLADERF_CORR_DCOFF_I + CorrectionDcoffQ Correction = C.BLADERF_CORR_DCOFF_Q + CorrectionPhase Correction = C.BLADERF_CORR_PHASE + CorrectionGain Correction = C.BLADERF_CORR_GAIN +) + +const ( + Tx Direction = C.BLADERF_TX + Rx Direction = C.BLADERF_RX +) + +const ( + SpeedUnknown DeviceSpeed = C.BLADERF_DEVICE_SPEED_UNKNOWN + SpeedHigh DeviceSpeed = C.BLADERF_DEVICE_SPEED_HIGH + SpeedSuper DeviceSpeed = C.BLADERF_DEVICE_SPEED_SUPER +) + +const ( + FormatSc16Q11 Format = C.BLADERF_FORMAT_SC16_Q11 + FormatSc16Q11Meta Format = C.BLADERF_FORMAT_SC16_Q11_META +) + +const ( + FpgaSizeUnknown FpgaSize = C.BLADERF_FPGA_UNKNOWN + FpgaSize40kle FpgaSize = C.BLADERF_FPGA_40KLE + FpgaSize115kle FpgaSize = C.BLADERF_FPGA_115KLE + FpgaSizeA4 FpgaSize = C.BLADERF_FPGA_A4 + FpgaSizeA9 FpgaSize = C.BLADERF_FPGA_A9 +) + +const ( + FpgaSourceUnknown FpgaSource = C.BLADERF_FPGA_SOURCE_UNKNOWN + FpgaSourceFlash FpgaSource = C.BLADERF_FPGA_SOURCE_FLASH + FpgaSourceHost FpgaSource = C.BLADERF_FPGA_SOURCE_HOST +) + +const ( + GainModeDefault GainMode = C.BLADERF_GAIN_DEFAULT + GainModeManual GainMode = C.BLADERF_GAIN_MGC + GainModeFastAttackAgc GainMode = C.BLADERF_GAIN_FASTATTACK_AGC + GainModeSlowAttackAgc GainMode = C.BLADERF_GAIN_SLOWATTACK_AGC + GainModeHybridAgc GainMode = C.BLADERF_GAIN_HYBRID_AGC +) + +const ( + ModuleTx Module = C.BLADERF_MODULE_TX + ModuleRx Module = C.BLADERF_MODULE_RX +) + +const ( + LoopbackDisabled Loopback = C.BLADERF_LB_NONE + LoopbackFirmware Loopback = C.BLADERF_LB_FIRMWARE + LoopbackBbTxlpfRxvga2 Loopback = C.BLADERF_LB_BB_TXLPF_RXVGA2 + LoopbackBbTxvga1Rxvga2 Loopback = C.BLADERF_LB_BB_TXVGA1_RXVGA2 + LoopbackBbTxlpfRxlpf Loopback = C.BLADERF_LB_BB_TXLPF_RXLPF + LoopbackBbTxvga1Rxlpf Loopback = C.BLADERF_LB_BB_TXVGA1_RXLPF + LoopbackRfLna1 Loopback = C.BLADERF_LB_RF_LNA1 + LoopbackRfLna2 Loopback = C.BLADERF_LB_RF_LNA2 + LoopbackRfLna3 Loopback = C.BLADERF_LB_RF_LNA3 + LoopbackRficBist Loopback = C.BLADERF_LB_RFIC_BIST +) + +const ( + PmicConfiguration PmicRegister = C.BLADERF_PMIC_CONFIGURATION + PmicVoltageShunt PmicRegister = C.BLADERF_PMIC_VOLTAGE_SHUNT + PmicVoltageBus PmicRegister = C.BLADERF_PMIC_VOLTAGE_BUS + PmicPower PmicRegister = C.BLADERF_PMIC_POWER + PmicCurrent PmicRegister = C.BLADERF_PMIC_CURRENT + PmicCalibration PmicRegister = C.BLADERF_PMIC_CALIBRATION +) + +const ( + PsUnknown PowerSource = C.BLADERF_UNKNOWN + PsDc PowerSource = C.BLADERF_PS_DC + PsUsbVbus PowerSource = C.BLADERF_PS_USB_VBUS +) + +const ( + RxMuxInvalid RxMux = C.BLADERF_RX_MUX_INVALID + RxMuxBaseband RxMux = C.BLADERF_RX_MUX_BASEBAND + RxMux12BitCounter RxMux = C.BLADERF_RX_MUX_12BIT_COUNTER + RxMux32BitCounter RxMux = C.BLADERF_RX_MUX_32BIT_COUNTER + RxMuxDigitalLoopback RxMux = C.BLADERF_RX_MUX_DIGITAL_LOOPBACK +) diff --git a/error/error.go b/error/error.go index df18fdb..c042279 100644 --- a/error/error.go +++ b/error/error.go @@ -27,7 +27,7 @@ const ( NotInit Code = -19 ) -func CodeToString(code Code) string { +func codeToString(code Code) string { switch code { case Unexpected: return "An unexpected failure occurred" @@ -85,5 +85,5 @@ func New(code int) error { return nil } - return &errorString{s: CodeToString(Code(code))} + return &errorString{s: codeToString(Code(code))} } diff --git a/format/format.go b/format/format.go deleted file mode 100644 index ae55380..0000000 --- a/format/format.go +++ /dev/null @@ -1,11 +0,0 @@ -package format - -// #include -import "C" - -type Format int - -const ( - SC16_Q11 Format = C.BLADERF_FORMAT_SC16_Q11 - SC16_Q11_META Format = C.BLADERF_FORMAT_SC16_Q11_META -) diff --git a/fpga_size/fpga_size.go b/fpga_size/fpga_size.go deleted file mode 100644 index 3b39be2..0000000 --- a/fpga_size/fpga_size.go +++ /dev/null @@ -1,14 +0,0 @@ -package fpga_size - -// #include -import "C" - -type FPGASize int - -const ( - SizeUnknown FPGASize = C.BLADERF_FPGA_UNKNOWN - Size40KLE FPGASize = C.BLADERF_FPGA_40KLE - Size115KLE FPGASize = C.BLADERF_FPGA_115KLE - SizeA4 FPGASize = C.BLADERF_FPGA_A4 - SizeA9 FPGASize = C.BLADERF_FPGA_A9 -) diff --git a/fpga_source/fpga_source.go b/fpga_source/fpga_source.go deleted file mode 100644 index b0d910e..0000000 --- a/fpga_source/fpga_source.go +++ /dev/null @@ -1,12 +0,0 @@ -package fpga_source - -// #include -import "C" - -type FPGASource int - -const ( - SourceUnknown FPGASource = C.BLADERF_FPGA_SOURCE_UNKNOWN - SourceFlash FPGASource = C.BLADERF_FPGA_SOURCE_FLASH - SourceHost FPGASource = C.BLADERF_FPGA_SOURCE_HOST -) diff --git a/gain_mode/gain_mode.go b/gain_mode/gain_mode.go deleted file mode 100644 index 024f1da..0000000 --- a/gain_mode/gain_mode.go +++ /dev/null @@ -1,14 +0,0 @@ -package gain_mode - -// #include -import "C" - -type GainMode int - -const ( - Default GainMode = C.BLADERF_GAIN_DEFAULT - Manual GainMode = C.BLADERF_GAIN_MGC - FastAttack_AGC GainMode = C.BLADERF_GAIN_FASTATTACK_AGC - SlowAttack_AGC GainMode = C.BLADERF_GAIN_SLOWATTACK_AGC - Hybrid_AGC GainMode = C.BLADERF_GAIN_HYBRID_AGC -) diff --git a/io_module/io_module.go b/io_module/io_module.go deleted file mode 100644 index 80ef66c..0000000 --- a/io_module/io_module.go +++ /dev/null @@ -1,11 +0,0 @@ -package io_module - -// #include -import "C" - -type IOModule int - -const ( - IOTX IOModule = C.BLADERF_MODULE_TX - IORX IOModule = C.BLADERF_MODULE_RX -) diff --git a/loopback/loopback.go b/loopback/loopback.go deleted file mode 100644 index 67d378f..0000000 --- a/loopback/loopback.go +++ /dev/null @@ -1,19 +0,0 @@ -package loopback - -// #include -import "C" - -type Loopback int - -const ( - Disabled Loopback = C.BLADERF_LB_NONE - Firmware Loopback = C.BLADERF_LB_FIRMWARE - BB_TXLPF_RXVGA2 Loopback = C.BLADERF_LB_BB_TXLPF_RXVGA2 - BB_TXVGA1_RXVGA2 Loopback = C.BLADERF_LB_BB_TXVGA1_RXVGA2 - BB_TXLPF_RXLPF Loopback = C.BLADERF_LB_BB_TXLPF_RXLPF - BB_TXVGA1_RXLPF Loopback = C.BLADERF_LB_BB_TXVGA1_RXLPF - RF_LNA1 Loopback = C.BLADERF_LB_RF_LNA1 - RF_LNA2 Loopback = C.BLADERF_LB_RF_LNA2 - RF_LNA3 Loopback = C.BLADERF_LB_RF_LNA3 - RFIC_BIST Loopback = C.BLADERF_LB_RFIC_BIST -) diff --git a/macros.go b/macros.go index 3a4be83..28f2601 100644 --- a/macros.go +++ b/macros.go @@ -2,12 +2,11 @@ package bladerf // #include "macro_wrapper.h" import "C" -import "github.com/erayarslan/go-bladerf/channel" -func CHANNEL_RX(ch int) channel.Channel { - return channel.Channel(C.ChannelRX(C.int(ch))) +func ChannelRx(ch int) Channel { + return Channel(C.ChannelRX(C.int(ch))) } -func CHANNEL_TX(ch int) channel.Channel { - return channel.Channel(C.ChannelTX(C.int(ch))) +func ChannelTx(ch int) Channel { + return Channel(C.ChannelTX(C.int(ch))) } diff --git a/pmic_register/pmic_register.go b/pmic_register/pmic_register.go deleted file mode 100644 index a8252fb..0000000 --- a/pmic_register/pmic_register.go +++ /dev/null @@ -1,15 +0,0 @@ -package pmic_register - -// #include -import "C" - -type PMICRegister int - -const ( - Configuration PMICRegister = C.BLADERF_PMIC_CONFIGURATION - Voltage_shunt PMICRegister = C.BLADERF_PMIC_VOLTAGE_SHUNT - Voltage_bus PMICRegister = C.BLADERF_PMIC_VOLTAGE_BUS - Power PMICRegister = C.BLADERF_PMIC_POWER - Current PMICRegister = C.BLADERF_PMIC_CURRENT - Calibration PMICRegister = C.BLADERF_PMIC_CALIBRATION -) diff --git a/power_source/power_source.go b/power_source/power_source.go deleted file mode 100644 index 7c60b2a..0000000 --- a/power_source/power_source.go +++ /dev/null @@ -1,12 +0,0 @@ -package power_source - -// #include -import "C" - -type PowerSource int - -const ( - PowerSourceUnknown PowerSource = C.BLADERF_UNKNOWN - PowerSourceDC_Barrel PowerSource = C.BLADERF_PS_DC - PowerSourceUSB_VBUS PowerSource = C.BLADERF_PS_USB_VBUS -) diff --git a/rx_mux/rx_mux.go b/rx_mux/rx_mux.go deleted file mode 100644 index ed2278a..0000000 --- a/rx_mux/rx_mux.go +++ /dev/null @@ -1,14 +0,0 @@ -package rx_mux - -// #include -import "C" - -type RXMux int - -const ( - Invalid RXMux = C.BLADERF_RX_MUX_INVALID - Baseband RXMux = C.BLADERF_RX_MUX_BASEBAND - Counter_12bit RXMux = C.BLADERF_RX_MUX_12BIT_COUNTER - Counter_32bit RXMux = C.BLADERF_RX_MUX_32BIT_COUNTER - Digital_Loopback RXMux = C.BLADERF_RX_MUX_DIGITAL_LOOPBACK -) diff --git a/structs.go b/structs.go index 78e2adb..8dab7aa 100644 --- a/structs.go +++ b/structs.go @@ -3,14 +3,9 @@ package bladerf // #include import "C" -import ( - "github.com/erayarslan/go-bladerf/backend" - "github.com/erayarslan/go-bladerf/gain_mode" -) - -type DevInfo struct { +type DeviceInfo struct { ref *C.struct_bladerf_devinfo - backend backend.Backend + backend Backend serial string usbBus int8 usbAddr int8 @@ -19,40 +14,40 @@ type DevInfo struct { product string } -func NewDevInfo(ref *C.struct_bladerf_devinfo) DevInfo { - devInfo := DevInfo{ref: ref} +func NewDeviceInfo(ref *C.struct_bladerf_devinfo) DeviceInfo { + deviceInfo := DeviceInfo{ref: ref} var serial []rune var manufacturer []rune var product []rune - for i := range devInfo.ref.serial { - if devInfo.ref.serial[i] != 0 { - serial = append(serial, rune(devInfo.ref.serial[i])) + for i := range deviceInfo.ref.serial { + if deviceInfo.ref.serial[i] != 0 { + serial = append(serial, rune(deviceInfo.ref.serial[i])) } } - for i := range devInfo.ref.manufacturer { - if devInfo.ref.manufacturer[i] != 0 { - manufacturer = append(manufacturer, rune(devInfo.ref.manufacturer[i])) + for i := range deviceInfo.ref.manufacturer { + if deviceInfo.ref.manufacturer[i] != 0 { + manufacturer = append(manufacturer, rune(deviceInfo.ref.manufacturer[i])) } } - for i := range devInfo.ref.product { - if devInfo.ref.product[i] != 0 { - product = append(product, rune(devInfo.ref.product[i])) + for i := range deviceInfo.ref.product { + if deviceInfo.ref.product[i] != 0 { + product = append(product, rune(deviceInfo.ref.product[i])) } } - devInfo.backend = backend.Backend(devInfo.ref.backend) - devInfo.serial = string(serial) - devInfo.usbBus = int8(devInfo.ref.usb_bus) - devInfo.usbAddr = int8(devInfo.ref.usb_addr) - devInfo.instance = uint(devInfo.ref.instance) - devInfo.manufacturer = string(manufacturer) - devInfo.product = string(product) + deviceInfo.backend = Backend(deviceInfo.ref.backend) + deviceInfo.serial = string(serial) + deviceInfo.usbBus = int8(deviceInfo.ref.usb_bus) + deviceInfo.usbAddr = int8(deviceInfo.ref.usb_addr) + deviceInfo.instance = uint(deviceInfo.ref.instance) + deviceInfo.manufacturer = string(manufacturer) + deviceInfo.product = string(product) - return devInfo + return deviceInfo } type Version struct { @@ -113,10 +108,6 @@ func NewSerial(ref *C.struct_bladerf_serial) Serial { return Serial{ref: ref, serial: string(serial)} } -type Module struct { - ref *C.struct_bladerf_module -} - type Stream struct { ref *C.struct_bladerf_stream } @@ -124,14 +115,14 @@ type Stream struct { type GainModes struct { ref *C.struct_bladerf_gain_modes name string - mode gain_mode.GainMode + mode GainMode } func NewGainModes(ref *C.struct_bladerf_gain_modes) GainModes { gainModes := GainModes{ref: ref} gainModes.name = C.GoString(gainModes.ref.name) - gainModes.mode = gain_mode.GainMode(gainModes.ref.mode) + gainModes.mode = GainMode(gainModes.ref.mode) return gainModes }