refactor

backend/backend.go

@@ -1,14 +0,0 @@
-package backend
-
-// #include <libbladeRF.h>
-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
-)

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))
+	err := GetError(C.bladerf_get_fpga_size(bladeRF.ref, &size))
-	return fpga_size.FPGASize(int(size)), err
+
+	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))
+	err := GetError(C.bladerf_get_fpga_source(bladeRF.ref, &source))
-	return fpga_source.FPGASource(int(source)), err
+
+	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))
+	err := GetError(C.bladerf_get_fpga_bytes(bladeRF.ref, &size))
-	return uint32(size), err
+
+	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))
+	err := GetError(C.bladerf_get_flash_size(bladeRF.ref, &size, &isGuess))
-	return uint32(size), bool(isGuess), err
+
+	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))
+	err := GetError(C.bladerf_fw_version(bladeRF.ref, &version))
-	return NewVersion(&version), err
+
+	if err != nil {
+		return Version{}, err
+	}
+
+	return NewVersion(&version), nil
 }
 
-func IsFpgaConfigured(bladeRF *BladeRF) (bool, error) {
+func IsFpgaConfigured(bladeRF BladeRF) (bool, error) {
-	out := C.bladerf_is_fpga_configured((*bladeRF).ref)
+	out := C.bladerf_is_fpga_configured(bladeRF.ref)
-	if int(out) < 0 {
+
+	if out < 0 {
 		return false, GetError(out)
 	}
 
-	return int(out) == 1, nil
+	return out == 1, nil
 }
 
-func GetDeviceSpeed(bladeRF *BladeRF) device_speed.DeviceSpeed {
+func GetDeviceSpeed(bladeRF BladeRF) DeviceSpeed {
-	return device_speed.DeviceSpeed(int(C.bladerf_device_speed((*bladeRF).ref)))
+	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))
+	err := GetError(C.bladerf_fpga_version(bladeRF.ref, &version))
-	return NewVersion(&version), err
+
+	if err != nil {
+		return Version{}, err
+	}
+
+	return NewVersion(&version), nil
 }
 
-func FreeDeviceList(devInfo DevInfo) {
+func FreeDeviceList(deviceInfo DeviceInfo) {
-	C.bladerf_free_device_list(devInfo.ref)
+	C.bladerf_free_device_list(deviceInfo.ref)
 }
 
-func GetDeviceList() []DevInfo {
+func GetDeviceList() ([]DeviceInfo, error) {
-	var devInfo *C.struct_bladerf_devinfo
+	var deviceInfo *C.struct_bladerf_devinfo
-	var devices []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(
+			devices = append(devices, NewDeviceInfo(
-				(*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(devInfo))+(uintptr(i)*size))),
+				(*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(deviceInfo))+(uintptr(i)*size))),
 			))
 		}
 
 		FreeDeviceList(devices[0])
 	}
 
-	return devices
+	return devices, nil
 }
 
-func GetBootloaderList() []DevInfo {
+func GetBootloaderList() ([]DeviceInfo, error) {
-	var devInfo *C.struct_bladerf_devinfo
+	var deviceInfo *C.struct_bladerf_devinfo
-	var devices []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(
+			devices = append(devices, NewDeviceInfo(
-				(*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(devInfo))+(uintptr(i)*size))),
+				(*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(deviceInfo))+(uintptr(i)*size))),
 			))
 		}
 
 		FreeDeviceList(devices[0])
 	}
 
-	return devices
+	return devices, nil
 }
 
-func InitDevInfo() DevInfo {
+func InitDeviceInfo() DeviceInfo {
-	var devInfo C.struct_bladerf_devinfo
+	var deviceInfo C.struct_bladerf_devinfo
-	C.bladerf_init_devinfo(&devInfo)
+	C.bladerf_init_devinfo(&deviceInfo)
-	return NewDevInfo(&devInfo)
+	return NewDeviceInfo(&deviceInfo)
 }
 
-func GetDevInfo(bladeRF *BladeRF) DevInfo {
+func GetDeviceInfo(bladeRF BladeRF) (DeviceInfo, error) {
-	var devInfo C.struct_bladerf_devinfo
+	var deviceInfo C.struct_bladerf_devinfo
-	C.bladerf_get_devinfo((*bladeRF).ref, &devInfo)
+	err := GetError(C.bladerf_get_devinfo(bladeRF.ref, &deviceInfo))
-	return NewDevInfo(&devInfo)
+
+	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 {
+func DeviceStringMatches(deviceString string, deviceInfo DeviceInfo) bool {
-	val := C.CString(devStr)
+	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 {
+func GetDeviceInfoFromString(deviceString string) (DeviceInfo, error) {
-	val := C.CString(devStr)
+	val := C.CString(deviceString)
 	defer C.free(unsafe.Pointer(val))
-	var devInfo C.struct_bladerf_devinfo
+
-	C.bladerf_get_devinfo_from_str(val, &devInfo)
+	var deviceInfo C.struct_bladerf_devinfo
-	return NewDevInfo(&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))
+	err := GetError(C.bladerf_open(&bladeRF, C.CString(identify)))
-	return BladeRF{ref: bladeRF}
+
+	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)
+	err := GetError(C.bladerf_open(&bladeRF, nil))
-	return BladeRF{ref: bladeRF}
+
+	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 {
+func SetLoopback(bladeRF BladeRF, loopback Loopback) error {
-	return GetError(C.bladerf_set_loopback((*bladeRF).ref, C.bladerf_loopback(loopback)))
+	return GetError(C.bladerf_set_loopback(bladeRF.ref, C.bladerf_loopback(loopback)))
 }
 
-func SetFrequency(bladeRF *BladeRF, channel channel.Channel, frequency int) error {
+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)))
+	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))
+	err := GetError(C.bladerf_set_sample_rate(bladeRF.ref, C.bladerf_channel(channel), C.bladerf_sample_rate(sampleRate), &actual))
-	return err
+
+	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))
+	err := GetError(C.bladerf_get_rational_sample_rate(bladeRF.ref, C.bladerf_channel(channel), &rate))
-	return NewRationalRate(&rate), err
+
+	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 {
+	if err != nil {
-	return GetError(C.bladerf_set_gain((*bladeRF).ref, C.bladerf_channel(channel), C.int(gain)))
+		return 0, err
-}
-
-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
 	}
 
-	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))
+	err := GetError(C.bladerf_get_gain_stage(bladeRF.ref, C.bladerf_channel(channel), val, &gain))
-	if err == nil {
+
-		return int(gain), nil
+	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))
+	err := GetError(C.bladerf_get_gain_mode(bladeRF.ref, C.bladerf_channel(channel), &mode))
-	result := gain_mode.GainMode(int(mode))
+
-	if err == nil {
+	if err != nil {
-		return result, nil
+		return 0, err
 	}
 
-	return result, err
+	return GainMode(mode), nil
 }
 
-func SetGainStage(bladeRF *BladeRF, channel channel.Channel, stage string, gain int) error {
+func SetGainStage(bladeRF BladeRF, 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
 	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))
+	return GetError(C.bladerf_set_gain_stage(bladeRF.ref, C.bladerf_channel(channel), val, C.bladerf_gain(gain)))
-
-	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
 }
 
-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{}, err
-	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 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 {
+func GetGainRange(bladeRF BladeRF, channel Channel) (Range, error) {
-	count := int(C.bladerf_get_gain_stages((*bladeRF).ref, C.bladerf_channel(channel), nil, 0))
+	var bfRange *C.struct_bladerf_range
+	err := GetError(C.bladerf_get_gain_range(bladeRF.ref, C.bladerf_channel(channel), &bfRange))
 
-	if count < 1 {
+	if err != nil {
-		return 0
+		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 {
+func GetBoardName(bladeRF BladeRF) string {
-	return C.GoString(C.bladerf_get_board_name((*bladeRF).ref))
+	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(
+	numberOfGainStages, err := GetNumberOfGainStages(bladeRF, channel)
-		(*bladeRF).ref,
+
+	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 {
+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)))
+	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 {
+func EnableModule(bladeRF BladeRF, channel Channel) error {
-	return GetError(C.bladerf_enable_module((*bladeRF).ref, C.bladerf_channel(channel), true))
+	return GetError(C.bladerf_enable_module(bladeRF.ref, C.bladerf_channel(channel), true))
 }
 
-func DisableModule(bladeRF *BladeRF, channel channel.Channel) error {
+func DisableModule(bladeRF BladeRF, channel Channel) error {
-	return GetError(C.bladerf_enable_module((*bladeRF).ref, C.bladerf_channel(channel), false))
+	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
+	if err != nil {
-	var results []int16
+		return nil, err
-
-	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
 	}
 
-	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))
+	err := GetError(C.bladerf_get_stream_timeout(bladeRF.ref, C.bladerf_direction(direction), &timeout))
-	return int(timeout), err
+
+	if err != nil {
+		return 0, err
+	}
+
+	return uint(timeout), err
 }
 
-func SetStreamTimeout(bladeRF *BladeRF, direction direction.Direction, timeout int) error {
+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)))
+	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 {
+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)))
+	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)))
 }

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)
+	x := BackendString(BackendLibUSB)
-	y := BackendSTR(backend.Dummy)
+	y := BackendString(BackendDummy)
-	z := BackendSTR(backend.Any)
+	z := BackendString(BackendAny)
-	a := BackendSTR(backend.Cypress)
+	a := BackendString(BackendCypress)
-	b := BackendSTR(backend.Linux)
+	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)
+	size, guess, err := GetFpgaFlashSize(rf)
-	fmt.Print(size)
+
-	fmt.Print(guess)
+	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])
+	rf, _ := OpenWithDeviceInfo(devices[0])
-	LoadFpga(rf, "/Users/erayarslan/Downloads/hostedxA4-latest.rbf")
+	_ = LoadFpga(rf, "/Users/erayarslan/Downloads/hostedxA4-latest.rbf")
 	Close(rf)
 
-	rf = Open()
+	rf, _ = Open()
-	info := GetDevInfo(&rf)
+	info, _ := GetDeviceInfo(rf)
 	Close(rf)
-	out, _ := OpenWithDevInfo(GetDevInfo(&rf))
+	h, _ := GetDeviceInfo(rf)
+	out, _ := OpenWithDeviceInfo(h)
 	Close(out)
-	Close(Open())
+	c1, _ := Open()
-	Close(OpenWithDeviceIdentifier("*:serial=" + info.serial))
+	Close(c1)
-	out2, _ := OpenWithDevInfo(GetDevInfoFromStr("*:serial=" + info.serial))
+	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])
+	bfRange, _ := GetGainStageRange(rf, ChannelRx(1), stages[0])
-	_ = SetGainStage(&rf, CHANNEL_RX(1), stages[0], int(bfRange.max))
+	_ = SetGainStage(rf, ChannelRx(1), stages[0], int(bfRange.max))
-	gain, _ := GetGainStage(&rf, CHANNEL_RX(1), stages[0])
+	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()
+	devices, _ := GetDeviceList()
-	channel := CHANNEL_RX(1)
+	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)
+	_ = SetFrequency(rf, channel, 96600000)
-	min, max, step, _ := GetSampleRateRange(&rf, channel)
+	min, max, step, _ := GetSampleRateRange(rf, channel)
 	fmt.Printf("Min: %d, Max: %d, Step: %d\n", min, max, step)
-	_ = SetSampleRate(&rf, channel, 4e6)
+	_, _ = SetSampleRate(rf, channel, 4e6)
-	_ = SyncConfig(&rf, channel_layout.RX_X2, format.SC16_Q11, 16, audioBufferSize, 8, 32)
+	_ = SyncConfig(rf, RxX2, FormatSc16Q11, 16, audioBufferSize, 8, 32)
-	actual, _ := SetBandwidth(&rf, channel, 240000)
+	actual, _ := SetBandwidth(rf, channel, 240000)
 	fmt.Println(actual)
-	_ = EnableModule(&rf, channel)
+	_ = EnableModule(rf, channel)
-	_ = SetGainMode(&rf, channel, gain_mode.Hybrid_AGC)
+	_ = 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)
+	_ = SetFrequency(rf, channel, 1525420000)
-	_ = SyncConfig(&rf, channel_layout.RX_X2, format.SC16_Q11, 16, audioBufferSize, 8, 32)
+	_ = SyncConfig(rf, RxX2, FormatSc16Q11, 16, audioBufferSize, 8, 32)
-	_ = SetSampleRate(&rf, channel, 2600000)
+	_, _ = SetSampleRate(rf, channel, 2600000)
-	_, _ = SetBandwidth(&rf, channel, 2500000)
+	_, _ = SetBandwidth(rf, channel, 2500000)
-	//_ = SetGainMode(&rf, channel, Hybrid_AGC)
+	_ = SetGainMode(rf, channel, GainModeHybridAgc)
-	_ = EnableModule(&rf, channel)
+	_ = 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)
+	_ = SetFrequency(rf, channel, 96600000)
-	_ = SetSampleRate(&rf, channel, 4e6)
+	_, _ = SetSampleRate(rf, channel, 4e6)
-	_, _ = SetBandwidth(&rf, channel, 240000)
+	_, _ = SetBandwidth(rf, channel, 240000)
-	//_ = SetGainMode(&rf, channel, Hybrid_AGC)
+	_ = SetGainMode(rf, channel, GainModeHybridAgc)
-	_ = EnableModule(&rf, channel)
+	_ = 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)
+	_ = SetStreamTimeout(rf, Rx, 32)
-	timeout, _ := GetStreamTimeout(&rf, direction.RX)
+	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")
 }

channel/channel.go

@@ -1,3 +0,0 @@
-package channel
-
-type Channel int

channel_layout/channel_layout.go

@@ -1,13 +0,0 @@
-package channel_layout
-
-// #include <libbladeRF.h>
-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
-)

clock_select/clock_select.go

@@ -1,12 +0,0 @@
-package clock_select
-
-// #include <libbladeRF.h>
-import "C"
-
-type ClockSelect int
-
-const (
-	ClockSelectUnknown  ClockSelect = -99
-	ClockSelectVCTCXO   ClockSelect = C.CLOCK_SELECT_ONBOARD
-	ClockSelectExternal ClockSelect = C.CLOCK_SELECT_EXTERNAL
-)

correction/correction.go

@@ -1,13 +0,0 @@
-package channel_layout
-
-// #include <libbladeRF.h>
-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
-)

device_speed/device_speed.go

@@ -1,12 +0,0 @@
-package device_speed
-
-// #include <libbladeRF.h>
-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
-)

direction/direction.go

@@ -1,11 +0,0 @@
-package direction
-
-// #include <libbladeRF.h>
-import "C"
-
-type Direction int
-
-const (
-	TX Direction = C.BLADERF_TX
-	RX Direction = C.BLADERF_RX
-)

enums.go

@@ -0,0 +1,126 @@
+package bladerf
+
+// #include <libbladeRF.h>
+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
+)

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))}
 }

format/format.go

@@ -1,11 +0,0 @@
-package format
-
-// #include <libbladeRF.h>
-import "C"
-
-type Format int
-
-const (
-	SC16_Q11      Format = C.BLADERF_FORMAT_SC16_Q11
-	SC16_Q11_META Format = C.BLADERF_FORMAT_SC16_Q11_META
-)

fpga_size/fpga_size.go

@@ -1,14 +0,0 @@
-package fpga_size
-
-// #include <libbladeRF.h>
-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
-)

fpga_source/fpga_source.go

@@ -1,12 +0,0 @@
-package fpga_source
-
-// #include <libbladeRF.h>
-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
-)

gain_mode/gain_mode.go

@@ -1,14 +0,0 @@
-package gain_mode
-
-// #include <libbladeRF.h>
-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
-)

io_module/io_module.go

@@ -1,11 +0,0 @@
-package io_module
-
-// #include <libbladeRF.h>
-import "C"
-
-type IOModule int
-
-const (
-	IOTX IOModule = C.BLADERF_MODULE_TX
-	IORX IOModule = C.BLADERF_MODULE_RX
-)

loopback/loopback.go

@@ -1,19 +0,0 @@
-package loopback
-
-// #include <libbladeRF.h>
-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
-)

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 {
+func ChannelRx(ch int) Channel {
-	return channel.Channel(C.ChannelRX(C.int(ch)))
+	return Channel(C.ChannelRX(C.int(ch)))
 }
 
-func CHANNEL_TX(ch int) channel.Channel {
+func ChannelTx(ch int) Channel {
-	return channel.Channel(C.ChannelTX(C.int(ch)))
+	return Channel(C.ChannelTX(C.int(ch)))
 }

pmic_register/pmic_register.go

@@ -1,15 +0,0 @@
-package pmic_register
-
-// #include <libbladeRF.h>
-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
-)

power_source/power_source.go

@@ -1,12 +0,0 @@
-package power_source
-
-// #include <libbladeRF.h>
-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
-)

rx_mux/rx_mux.go

@@ -1,14 +0,0 @@
-package rx_mux
-
-// #include <libbladeRF.h>
-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
-)

structs.go

@@ -3,14 +3,9 @@ package bladerf
 // #include <libbladeRF.h>
 import "C"
 
-import (
+type DeviceInfo struct {
-	"github.com/erayarslan/go-bladerf/backend"
-	"github.com/erayarslan/go-bladerf/gain_mode"
-)
-
-type DevInfo 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 {
+func NewDeviceInfo(ref *C.struct_bladerf_devinfo) DeviceInfo {
-	devInfo := DevInfo{ref: ref}
+	deviceInfo := DeviceInfo{ref: ref}
 
 	var serial []rune
 	var manufacturer []rune
 	var product []rune
 
-	for i := range devInfo.ref.serial {
+	for i := range deviceInfo.ref.serial {
-		if devInfo.ref.serial[i] != 0 {
+		if deviceInfo.ref.serial[i] != 0 {
-			serial = append(serial, rune(devInfo.ref.serial[i]))
+			serial = append(serial, rune(deviceInfo.ref.serial[i]))
 		}
 	}
 
-	for i := range devInfo.ref.manufacturer {
+	for i := range deviceInfo.ref.manufacturer {
-		if devInfo.ref.manufacturer[i] != 0 {
+		if deviceInfo.ref.manufacturer[i] != 0 {
-			manufacturer = append(manufacturer, rune(devInfo.ref.manufacturer[i]))
+			manufacturer = append(manufacturer, rune(deviceInfo.ref.manufacturer[i]))
 		}
 	}
 
-	for i := range devInfo.ref.product {
+	for i := range deviceInfo.ref.product {
-		if devInfo.ref.product[i] != 0 {
+		if deviceInfo.ref.product[i] != 0 {
-			product = append(product, rune(devInfo.ref.product[i]))
+			product = append(product, rune(deviceInfo.ref.product[i]))
 		}
 	}
 
-	devInfo.backend = backend.Backend(devInfo.ref.backend)
+	deviceInfo.backend = Backend(deviceInfo.ref.backend)
-	devInfo.serial = string(serial)
+	deviceInfo.serial = string(serial)
-	devInfo.usbBus = int8(devInfo.ref.usb_bus)
+	deviceInfo.usbBus = int8(deviceInfo.ref.usb_bus)
-	devInfo.usbAddr = int8(devInfo.ref.usb_addr)
+	deviceInfo.usbAddr = int8(deviceInfo.ref.usb_addr)
-	devInfo.instance = uint(devInfo.ref.instance)
+	deviceInfo.instance = uint(deviceInfo.ref.instance)
-	devInfo.manufacturer = string(manufacturer)
+	deviceInfo.manufacturer = string(manufacturer)
-	devInfo.product = string(product)
+	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
 }