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

refactor

This commit is contained in:
Eray Arslan 2021-05-20 01:16:00 +03:00
parent fa6d36290b
commit 7d632c6ad3
22 changed files with 624 additions and 551 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
backend/backend.go
View File

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

480
bladerf.go
View File

@ -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
}
func GetFpgaSource(bladeRF *BladeRF) (fpga_source.FPGASource, error) {
return FpgaSize(size), nil
}
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
}
func GetFpgaBytes(bladeRF *BladeRF) (uint32, error) {
return FpgaSource(source), nil
}
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
}
func GetFpgaFlashSize(bladeRF *BladeRF) (uint32, bool, error) {
return uint32(size), nil
}
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
}
func GetFirmwareVersion(bladeRF *BladeRF) (Version, error) {
return uint32(size), bool(isGuess), nil
}
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
}
func IsFpgaConfigured(bladeRF *BladeRF) (bool, error) {
out := C.bladerf_is_fpga_configured((*bladeRF).ref)
if int(out) < 0 {
return NewVersion(&version), nil
}
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
}
func FreeDeviceList(devInfo DevInfo) {
C.bladerf_free_device_list(devInfo.ref)
return NewVersion(&version), nil
}
func GetDeviceList() []DevInfo {
var devInfo *C.struct_bladerf_devinfo
var devices []DevInfo
func FreeDeviceList(deviceInfo DeviceInfo) {
C.bladerf_free_device_list(deviceInfo.ref)
}
count := int(C.bladerf_get_device_list(&devInfo))
func GetDeviceList() ([]DeviceInfo, error) {
var deviceInfo *C.struct_bladerf_devinfo
var devices []DeviceInfo
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
}
func DevInfoMatches(a DevInfo, b DevInfo) bool {
return NewDeviceInfo(&deviceInfo), nil
}
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
}
func OpenWithDevInfo(devInfo DevInfo) (BladeRF, error) {
return NewDeviceInfo(&deviceInfo), nil
}
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
}
func Open() BladeRF {
return BladeRF{ref: bladeRF}, nil
}
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
}
func GetRationalSampleRate(bladeRF *BladeRF, channel channel.Channel) (RationalRate, error) {
return uint(actual), err
}
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
}
func GetSampleRateRange(bladeRF *BladeRF, channel channel.Channel) (int, int, int, error) {
return NewRationalRate(&rate), nil
}
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,63 +323,76 @@ 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))
if err != nil {
return 0, err
}
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)))
return uint(actual), nil
}
func GetGain(bladeRF *BladeRF, channel channel.Channel) (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 {
err := GetError(C.bladerf_get_gain(bladeRF.ref, C.bladerf_channel(channel), &gain))
if err != nil {
return 0, err
}
return int(gain), nil
}
return int(gain), err
}
func GetGainStage(bladeRF *BladeRF, channel channel.Channel, stage string) (int, error) {
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 {
err := GetError(C.bladerf_get_gain_stage(bladeRF.ref, C.bladerf_channel(channel), val, &gain))
if err != nil {
return 0, err
}
return int(gain), nil
}
return int(gain), err
}
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 {
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)))
return GetError(C.bladerf_set_gain_stage(bladeRF.ref, C.bladerf_channel(channel), val, C.bladerf_gain(gain)))
}
func GetGainStageRange(bladeRF *BladeRF, channel channel.Channel, stage string) (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
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))
err := GetError(C.bladerf_get_gain_stage_range((*bladeRF).ref, C.bladerf_channel(channel), val, &bfRange))
if err != nil {
return Range{}, err
}
if err == nil {
return Range{
ref: bfRange,
min: int64(bfRange.min),
@ -316,15 +402,14 @@ func GetGainStageRange(bladeRF *BladeRF, channel channel.Channel, stage string)
}, nil
}
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 err != nil {
return Range{}, err
}
func GetGainRange(bladeRF *BladeRF, channel 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 err == nil {
return Range{
ref: bfRange,
min: int64(bfRange.min),
@ -334,54 +419,77 @@ func GetGainRange(bladeRF *BladeRF, channel channel.Channel) (Range, error) {
}, nil
}
return Range{}, err
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)
}
func GetNumberOfGainStages(bladeRF *BladeRF, channel channel.Channel) int {
count := int(C.bladerf_get_gain_stages((*bladeRF).ref, C.bladerf_channel(channel), nil, 0))
if count < 1 {
return 0
return int(countOrCode), nil
}
return count
}
func BackendSTR(backend backend.Backend) string {
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,32 +529,32 @@ 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))
if err != nil {
return nil, err
}
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))
@ -445,18 +563,17 @@ func SyncRX(bladeRF *BladeRF, bufferSize uintptr) ([]int16, error) {
return results, nil
}
return nil, err
}
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
}
func DeInitStream(stream *Stream) {
return stream, nil
}
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
}
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)))
return uint(timeout), err
}
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 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 StartStream(stream *Stream, layout channel_layout.ChannelLayout) 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)))
}
func StartStream(stream Stream, layout ChannelLayout) error {
return GetError(C.bladerf_stream(stream.ref, C.bladerf_channel_layout(layout)))
}

249
bladerf_test.go
View File

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

3
channel/channel.go
View File

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

13
channel_layout/channel_layout.go
View File

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

12
clock_select/clock_select.go
View File

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

13
correction/correction.go
View File

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

12
device_speed/device_speed.go
View File

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

11
direction/direction.go
View File

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

126
enums.go Normal file
View File

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

4
error/error.go
View File

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

11
format/format.go
View File

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

14
fpga_size/fpga_size.go
View File

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

12
fpga_source/fpga_source.go
View File

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

14
gain_mode/gain_mode.go
View File

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

11
io_module/io_module.go
View File

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

19
loopback/loopback.go
View File

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

9
macros.go
View File

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

15
pmic_register/pmic_register.go
View File

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

12
power_source/power_source.go
View File

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

14
rx_mux/rx_mux.go
View File

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

55
structs.go
View File

@ -3,14 +3,9 @@ package bladerf
// #include <libbladeRF.h>
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
}