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

some shits

This commit is contained in:
Eray Arslan 2020-08-06 22:57:09 +03:00
parent 024dc212d4
commit 8d2c0fa989
5 changed files with 267 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

322
bladerf.go
View File

@ -7,9 +7,10 @@ import "C"
// #cgo LDFLAGS: -lbladeRF // #cgo LDFLAGS: -lbladeRF
// #include <libbladeRF.h> // #include <libbladeRF.h>
// //
// extern void* cbGo(struct bladerf *dev, struct bladerf_stream *stream, struct bladerf_metadata *md, void* samples, size_t num_samples, void* user_data); // extern void* StreamCallback(struct bladerf *dev, struct bladerf_stream *stream, struct bladerf_metadata *md, void* samples, size_t num_samples, void* user_data);
import "C" import "C"
import ( import (
"bladerf/channel"
"bladerf/channel_layout" "bladerf/channel_layout"
"bladerf/direction" "bladerf/direction"
exception "bladerf/error" exception "bladerf/error"
@ -25,60 +26,42 @@ func GetError(code C.int) error {
return exception.New(int(code)) return exception.New(int(code))
} }
var buff *C.int16_t //export StreamCallback
func StreamCallback(dev *C.struct_bladerf, stream *C.struct_bladerf_stream, metadata *C.struct_bladerf_metadata, samples unsafe.Pointer, numSamples C.size_t, userData unsafe.Pointer) unsafe.Pointer {
ud := pointer.Restore(userData).(UserData)
const size = unsafe.Sizeof(*buff) for i := uint32(0); i < uint32(numSamples); i++ {
ud.results[i] = int16(*((*C.int16_t)(unsafe.Pointer(uintptr(samples) + (C.sizeof_int16_t * uintptr(i))))))
//export cbGo
func cbGo(dev *C.struct_bladerf,
stream *C.struct_bladerf_stream,
metadata *C.struct_bladerf_metadata,
samples unsafe.Pointer,
numSamples C.size_t,
userData unsafe.Pointer) unsafe.Pointer {
cb := pointer.Restore(userData).(Callback)
for i := 0; i < cb.bufferSize; i++ {
cb.results[i] = int16(*((*C.int16_t)(unsafe.Pointer(uintptr(samples) + (size * uintptr(i))))))
} }
cb.cb(cb.results) ud.callback(ud.results)
return samples
return samples // C.malloc(C.size_t(size * cb.bufferSize * 2 * 1)) allocate always fcjinf new
} }
type Channel int
const (
RX_V int = 0x0
TX_V int = 0x1
)
const (
BLADERF_VCTCXO_FREQUENCY = 38.4e6
BLADERF_REFIN_DEFAULT = 10.0e6
BLADERF_SERIAL_LENGTH = 33
)
func GetVersion() Version { func GetVersion() Version {
var version C.struct_bladerf_version var version C.struct_bladerf_version
C.bladerf_version(&version) C.bladerf_version(&version)
return Version{version: &version, major: int(version.major), minor: int(version.minor), patch: int(version.patch), describe: C.GoString(version.describe)} return Version{
ref: &version,
major: uint16(version.major),
minor: uint16(version.minor),
patch: uint16(version.patch),
describe: C.GoString(version.describe),
}
} }
func PrintVersion(version Version) { func PrintVersion(version Version) {
fmt.Printf("v%d.%d.%d (\"%s\")", version.major, version.minor, version.patch, version.describe) fmt.Printf("v%d.%d.%d (\"%s\")", version.major, version.minor, version.patch, version.describe)
} }
func LoadFpga(bladeRF BladeRF, imagePath string) { func LoadFpga(bladeRF BladeRF, imagePath string) error {
path := C.CString(imagePath) path := C.CString(imagePath)
defer C.free(unsafe.Pointer(path)) defer C.free(unsafe.Pointer(path))
return GetError(C.bladerf_load_fpga(bladeRF.ref, path))
C.bladerf_load_fpga(bladeRF.bladeRF, path)
} }
func FreeDeviceList(devInfo DevInfo) { func FreeDeviceList(devInfo DevInfo) {
C.bladerf_free_device_list(devInfo.devInfo) C.bladerf_free_device_list(devInfo.ref)
} }
func GetDeviceList() []DevInfo { func GetDeviceList() []DevInfo {
@ -87,20 +70,16 @@ func GetDeviceList() []DevInfo {
count := int(C.bladerf_get_device_list(&devInfo)) count := int(C.bladerf_get_device_list(&devInfo))
if count < 1 { if count > 0 {
return devices
}
first := DevInfo{devInfo: devInfo}
defer FreeDeviceList(first)
devices = append(devices, first)
for i := 0; i < count-1; i++ {
size := unsafe.Sizeof(*devInfo) size := unsafe.Sizeof(*devInfo)
devInfo = (*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(devInfo)) + size))
devices = append(devices, DevInfo{devInfo: devInfo}) for i := 0; i < count; i++ {
devices = append(devices, NewDevInfo(
(*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(devInfo))+(uintptr(i)*size))),
))
}
FreeDeviceList(devices[0])
} }
return devices return devices
@ -112,20 +91,16 @@ func GetBootloaderList() []DevInfo {
count := int(C.bladerf_get_bootloader_list(&devInfo)) count := int(C.bladerf_get_bootloader_list(&devInfo))
if count < 1 { if count > 0 {
return devices
}
first := DevInfo{devInfo: devInfo}
defer FreeDeviceList(first)
devices = append(devices, first)
for i := 0; i < count-1; i++ {
size := unsafe.Sizeof(*devInfo) size := unsafe.Sizeof(*devInfo)
devInfo = (*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(devInfo)) + size))
devices = append(devices, DevInfo{devInfo: devInfo}) for i := 0; i < count; i++ {
devices = append(devices, NewDevInfo(
(*C.struct_bladerf_devinfo)(unsafe.Pointer(uintptr(unsafe.Pointer(devInfo))+(uintptr(i)*size))),
))
}
FreeDeviceList(devices[0])
} }
return devices return devices
@ -134,75 +109,66 @@ func GetBootloaderList() []DevInfo {
func InitDevInfo() DevInfo { func InitDevInfo() DevInfo {
var devInfo C.struct_bladerf_devinfo var devInfo C.struct_bladerf_devinfo
C.bladerf_init_devinfo(&devInfo) C.bladerf_init_devinfo(&devInfo)
return DevInfo{devInfo: &devInfo} return NewDevInfo(&devInfo)
} }
func GetDevInfo(bladeRF *BladeRF) DevInfo { func GetDevInfo(bladeRF *BladeRF) DevInfo {
var devInfo C.struct_bladerf_devinfo var devInfo C.struct_bladerf_devinfo
C.bladerf_get_devinfo((*bladeRF).bladeRF, &devInfo) C.bladerf_get_devinfo((*bladeRF).ref, &devInfo)
return NewDevInfo(&devInfo)
var fs []rune
for i := range devInfo.serial {
if devInfo.serial[i] != 0 {
fs = append(fs, rune(devInfo.serial[i]))
}
}
info := DevInfo{devInfo: &devInfo, serial: string(fs)}
return info
} }
func DevInfoMatches(a DevInfo, b DevInfo) bool { func DevInfoMatches(a DevInfo, b DevInfo) bool {
return bool(C.bladerf_devinfo_matches(a.devInfo, b.devInfo)) return bool(C.bladerf_devinfo_matches(a.ref, b.ref))
} }
func DevStrMatches(devstr string, info DevInfo) bool { func DevStrMatches(devStr string, info DevInfo) bool {
val := C.CString(devstr) val := C.CString(devStr)
defer C.free(unsafe.Pointer(val)) defer C.free(unsafe.Pointer(val))
return bool(C.bladerf_devstr_matches(val, info.devInfo)) return bool(C.bladerf_devstr_matches(val, info.ref))
} }
func GetDevInfoFromStr(devstr string) DevInfo { func GetDevInfoFromStr(devStr string) DevInfo {
val := C.CString(devstr) val := C.CString(devStr)
defer C.free(unsafe.Pointer(val)) defer C.free(unsafe.Pointer(val))
var devInfo C.struct_bladerf_devinfo var devInfo C.struct_bladerf_devinfo
C.bladerf_get_devinfo_from_str(val, &devInfo) C.bladerf_get_devinfo_from_str(val, &devInfo)
return DevInfo{devInfo: &devInfo} return NewDevInfo(&devInfo)
} }
func OpenWithDevInfo(devInfo DevInfo) BladeRF { func OpenWithDevInfo(devInfo DevInfo) BladeRF {
var bladeRF *C.struct_bladerf var bladeRF *C.struct_bladerf
C.bladerf_open_with_devinfo(&bladeRF, devInfo.devInfo) C.bladerf_open_with_devinfo(&bladeRF, devInfo.ref)
return BladeRF{bladeRF: bladeRF} return BladeRF{ref: bladeRF}
} }
func OpenWithDeviceIdentifier(identify string) BladeRF { func OpenWithDeviceIdentifier(identify string) BladeRF {
var bladeRF *C.struct_bladerf var bladeRF *C.struct_bladerf
C.bladerf_open(&bladeRF, C.CString(identify)) C.bladerf_open(&bladeRF, C.CString(identify))
return BladeRF{bladeRF: bladeRF} return BladeRF{ref: bladeRF}
} }
func Open() BladeRF { func Open() BladeRF {
var bladeRF *C.struct_bladerf var bladeRF *C.struct_bladerf
C.bladerf_open(&bladeRF, nil) C.bladerf_open(&bladeRF, nil)
return BladeRF{bladeRF: bladeRF} return BladeRF{ref: bladeRF}
} }
func Close(bladeRF BladeRF) { func Close(bladeRF BladeRF) {
C.bladerf_close(bladeRF.bladeRF) C.bladerf_close(bladeRF.ref)
} }
func SetLoopback(bladeRF *BladeRF, loopback loopback.Loopback) { func SetLoopback(bladeRF *BladeRF, loopback loopback.Loopback) error {
C.bladerf_set_loopback((*bladeRF).bladeRF, C.bladerf_loopback(loopback)) return GetError(C.bladerf_set_loopback((*bladeRF).ref, C.bladerf_loopback(loopback)))
} }
func SetFrequency(bladeRF *BladeRF, channel Channel, frequency int) error { func SetFrequency(bladeRF *BladeRF, channel channel.Channel, frequency int) error {
return GetError(C.bladerf_set_frequency((*bladeRF).bladeRF, C.bladerf_channel(channel), C.ulonglong(frequency))) return GetError(C.bladerf_set_frequency((*bladeRF).ref, C.bladerf_channel(channel), C.ulonglong(frequency)))
} }
func SetSampleRate(bladeRF *BladeRF, channel Channel, sampleRate int) error { func SetSampleRate(bladeRF *BladeRF, channel channel.Channel, sampleRate int) error {
var actual C.uint var actual C.uint
err := GetError(C.bladerf_set_sample_rate((*bladeRF).bladeRF, C.bladerf_channel(channel), C.uint(sampleRate), &actual)) err := GetError(C.bladerf_set_sample_rate((*bladeRF).ref, C.bladerf_channel(channel), C.uint(sampleRate), &actual))
if err == nil { if err == nil {
println(uint(actual)) println(uint(actual))
@ -211,10 +177,10 @@ func SetSampleRate(bladeRF *BladeRF, channel Channel, sampleRate int) error {
return err return err
} }
func GetSampleRateRange(bladeRF *BladeRF, channel Channel) (int, int, int, error) { func GetSampleRateRange(bladeRF *BladeRF, channel channel.Channel) (int, int, int, error) {
var bfRange *C.struct_bladerf_range var bfRange *C.struct_bladerf_range
err := GetError(C.bladerf_get_sample_rate_range((*bladeRF).bladeRF, C.bladerf_channel(channel), &bfRange)) err := GetError(C.bladerf_get_sample_rate_range((*bladeRF).ref, C.bladerf_channel(channel), &bfRange))
if err != nil { if err != nil {
return 0, 0, 0, err return 0, 0, 0, err
@ -223,18 +189,18 @@ func GetSampleRateRange(bladeRF *BladeRF, channel Channel) (int, int, int, error
return int(bfRange.min), int(bfRange.max), int(bfRange.step), nil return int(bfRange.min), int(bfRange.max), int(bfRange.step), nil
} }
func SetBandwidth(bladeRF *BladeRF, channel Channel, bandwidth int) (int, error) { func SetBandwidth(bladeRF *BladeRF, channel channel.Channel, bandwidth int) (int, error) {
var actual C.bladerf_bandwidth var actual C.bladerf_bandwidth
return int(actual), GetError(C.bladerf_set_bandwidth((*bladeRF).bladeRF, C.bladerf_channel(channel), C.uint(bandwidth), &actual)) return int(actual), GetError(C.bladerf_set_bandwidth((*bladeRF).ref, C.bladerf_channel(channel), C.uint(bandwidth), &actual))
} }
func SetGain(bladeRF *BladeRF, channel Channel, gain int) error { func SetGain(bladeRF *BladeRF, channel channel.Channel, gain int) error {
return GetError(C.bladerf_set_gain((*bladeRF).bladeRF, C.bladerf_channel(channel), C.int(gain))) return GetError(C.bladerf_set_gain((*bladeRF).ref, C.bladerf_channel(channel), C.int(gain)))
} }
func GetGain(bladeRF *BladeRF, channel Channel) (int, error) { func GetGain(bladeRF *BladeRF, channel channel.Channel) (int, error) {
var gain C.bladerf_gain var gain C.bladerf_gain
err := GetError(C.bladerf_get_gain((*bladeRF).bladeRF, C.bladerf_channel(channel), &gain)) err := GetError(C.bladerf_get_gain((*bladeRF).ref, C.bladerf_channel(channel), &gain))
if err == nil { if err == nil {
return int(gain), nil return int(gain), nil
} }
@ -242,11 +208,11 @@ func GetGain(bladeRF *BladeRF, channel Channel) (int, error) {
return int(gain), err return int(gain), err
} }
func GetGainStage(bladeRF *BladeRF, channel Channel, stage string) (int, error) { func GetGainStage(bladeRF *BladeRF, channel channel.Channel, stage string) (int, error) {
val := C.CString(stage) val := C.CString(stage)
defer C.free(unsafe.Pointer(val)) defer C.free(unsafe.Pointer(val))
var gain C.bladerf_gain var gain C.bladerf_gain
err := GetError(C.bladerf_get_gain_stage((*bladeRF).bladeRF, C.bladerf_channel(channel), val, &gain)) err := GetError(C.bladerf_get_gain_stage((*bladeRF).ref, C.bladerf_channel(channel), val, &gain))
if err == nil { if err == nil {
return int(gain), nil return int(gain), nil
} }
@ -254,10 +220,10 @@ func GetGainStage(bladeRF *BladeRF, channel Channel, stage string) (int, error)
return int(gain), err return int(gain), err
} }
func GetGainMode(bladeRF *BladeRF, channel Channel) (gain_mode.GainMode, error) { func GetGainMode(bladeRF *BladeRF, channel channel.Channel) (gain_mode.GainMode, error) {
var mode C.bladerf_gain_mode var mode C.bladerf_gain_mode
err := GetError(C.bladerf_get_gain_mode((*bladeRF).bladeRF, 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)) result := gain_mode.GainMode(int(mode))
if err == nil { if err == nil {
return result, nil return result, nil
@ -266,52 +232,52 @@ func GetGainMode(bladeRF *BladeRF, channel Channel) (gain_mode.GainMode, error)
return result, err return result, err
} }
func SetGainStage(bladeRF *BladeRF, channel Channel, stage string, gain int) error { func SetGainStage(bladeRF *BladeRF, channel channel.Channel, stage string, gain int) error {
val := C.CString(stage) val := C.CString(stage)
defer C.free(unsafe.Pointer(val)) defer C.free(unsafe.Pointer(val))
return GetError(C.bladerf_set_gain_stage((*bladeRF).bladeRF, C.bladerf_channel(channel), val, C.int(gain))) return GetError(C.bladerf_set_gain_stage((*bladeRF).ref, C.bladerf_channel(channel), val, C.int(gain)))
} }
func GetGainStageRange(bladeRF *BladeRF, channel Channel, stage string) (Range, error) { func GetGainStageRange(bladeRF *BladeRF, channel channel.Channel, stage string) (Range, error) {
var bfRange *C.struct_bladerf_range var bfRange *C.struct_bladerf_range
val := C.CString(stage) val := C.CString(stage)
defer C.free(unsafe.Pointer(val)) defer C.free(unsafe.Pointer(val))
err := GetError(C.bladerf_get_gain_stage_range((*bladeRF).bladeRF, 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 { if err == nil {
return Range{ return Range{
bfRange: bfRange, ref: bfRange,
min: int64(bfRange.min), min: int64(bfRange.min),
max: int64(bfRange.max), max: int64(bfRange.max),
step: int64(bfRange.step), step: int64(bfRange.step),
scale: float64(bfRange.scale), scale: float64(bfRange.scale),
}, nil }, nil
} }
return Range{}, err return Range{}, err
} }
func GetGainRange(bladeRF *BladeRF, channel Channel) (Range, error) { func GetGainRange(bladeRF *BladeRF, channel channel.Channel) (Range, error) {
var bfRange *C.struct_bladerf_range var bfRange *C.struct_bladerf_range
err := GetError(C.bladerf_get_gain_range((*bladeRF).bladeRF, C.bladerf_channel(channel), &bfRange)) err := GetError(C.bladerf_get_gain_range((*bladeRF).ref, C.bladerf_channel(channel), &bfRange))
if err == nil { if err == nil {
return Range{ return Range{
bfRange: bfRange, ref: bfRange,
min: int64(bfRange.min), min: int64(bfRange.min),
max: int64(bfRange.max), max: int64(bfRange.max),
step: int64(bfRange.step), step: int64(bfRange.step),
scale: float64(bfRange.scale), scale: float64(bfRange.scale),
}, nil }, nil
} }
return Range{}, err return Range{}, err
} }
func GetNumberOfGainStages(bladeRF *BladeRF, channel Channel) int { func GetNumberOfGainStages(bladeRF *BladeRF, channel channel.Channel) int {
count := int(C.bladerf_get_gain_stages((*bladeRF).bladeRF, C.bladerf_channel(channel), nil, 0)) count := int(C.bladerf_get_gain_stages((*bladeRF).ref, C.bladerf_channel(channel), nil, 0))
if count < 1 { if count < 1 {
return 0 return 0
@ -320,150 +286,122 @@ func GetNumberOfGainStages(bladeRF *BladeRF, channel Channel) int {
return count return count
} }
func GetGainStages(bladeRF *BladeRF, channel Channel) []string { func GetGainStages(bladeRF *BladeRF, channel channel.Channel) []string {
var stage *C.char var stage *C.char
var stages []string var stages []string
count := int(C.bladerf_get_gain_stages( count := int(C.bladerf_get_gain_stages(
(*bladeRF).bladeRF, (*bladeRF).ref,
C.bladerf_channel(channel), C.bladerf_channel(channel),
&stage, &stage,
C.ulong(GetNumberOfGainStages(bladeRF, channel))), C.ulong(GetNumberOfGainStages(bladeRF, channel))),
) )
if count < 1 { if count > 0 {
return stages
}
first := C.GoString(stage)
stages = append(stages, first)
for i := 0; i < count-1; i++ {
size := unsafe.Sizeof(*stage) size := unsafe.Sizeof(*stage)
stage = (*C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(stage)) + size))
stages = append(stages, C.GoString(stage)) for i := 0; i < count; i++ {
stages = append(stages, C.GoString(
(*C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(stage))+(uintptr(i)*size))),
))
}
} }
return stages return stages
} }
func GetGainModes(bladeRF *BladeRF, channel Channel) []GainModes { func GetGainModes(bladeRF *BladeRF, channel channel.Channel) []GainModes {
var gainMode *C.struct_bladerf_gain_modes var gainMode *C.struct_bladerf_gain_modes
var gainModes []GainModes var gainModes []GainModes
count := int(C.bladerf_get_gain_modes((*bladeRF).bladeRF, C.bladerf_channel(channel), &gainMode)) count := int(C.bladerf_get_gain_modes((*bladeRF).ref, C.bladerf_channel(channel), &gainMode))
if count < 1 { if count > 0 {
return gainModes
}
first := GainModes{
gainModes: gainMode,
name: C.GoString(gainMode.name),
mode: gain_mode.GainMode(gainMode.mode),
}
gainModes = append(gainModes, first)
for i := 0; i < count-1; i++ {
size := unsafe.Sizeof(*gainMode) size := unsafe.Sizeof(*gainMode)
gainMode = (*C.struct_bladerf_gain_modes)(unsafe.Pointer(uintptr(unsafe.Pointer(gainMode)) + size))
gainModes = append(gainModes, GainModes{ for i := 0; i < count; i++ {
gainModes: gainMode, gainModes = append(gainModes, NewGainModes(
name: C.GoString(gainMode.name), (*C.struct_bladerf_gain_modes)(unsafe.Pointer(uintptr(unsafe.Pointer(gainMode))+(uintptr(i)*size))),
mode: gain_mode.GainMode(gainMode.mode), ))
}) }
} }
return gainModes return gainModes
} }
func SetGainMode(bladeRF *BladeRF, channel Channel, mode gain_mode.GainMode) error { func SetGainMode(bladeRF *BladeRF, channel channel.Channel, mode gain_mode.GainMode) error {
return GetError(C.bladerf_set_gain_mode((*bladeRF).bladeRF, 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) error { func EnableModule(bladeRF *BladeRF, channel channel.Channel) error {
return GetError(C.bladerf_enable_module((*bladeRF).bladeRF, C.bladerf_channel(channel), true)) return GetError(C.bladerf_enable_module((*bladeRF).ref, C.bladerf_channel(channel), true))
} }
func DisableModule(bladeRF *BladeRF, channel Channel) error { func DisableModule(bladeRF *BladeRF, channel channel.Channel) error {
return GetError(C.bladerf_enable_module((*bladeRF).bladeRF, 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 { func SyncRX(bladeRF *BladeRF, bufferSize uintptr) ([]int16, error) {
var metadata C.struct_bladerf_metadata var metadata C.struct_bladerf_metadata
start := C.malloc(C.size_t(size * bufferSize * 2 * 1)) start := C.malloc(C.size_t(C.sizeof_int16_t * bufferSize * 2 * 1))
var err error var err error
var results []int16 var results []int16
err = GetError(C.bladerf_sync_rx((*bladeRF).bladeRF, start, C.uint(bufferSize), &metadata, 32)) err = GetError(C.bladerf_sync_rx((*bladeRF).ref, start, C.uint(bufferSize), &metadata, 32))
if err == nil { if err == nil {
for i := 0; i < (int(metadata.actual_count)); i++ { for i := 0; i < (int(metadata.actual_count)); i++ {
n := (*C.int16_t)(unsafe.Pointer(uintptr(start) + (size * uintptr(i)))) n := (*C.int16_t)(unsafe.Pointer(uintptr(start) + (C.sizeof_int16_t * uintptr(i))))
results = append(results, int16(*n)) results = append(results, int16(*n))
} }
} else {
fmt.Printf("Failed to RX samples: %s", err) return results, nil
} }
return results return nil, err
}
type Callback struct {
cb func(data []int16)
results []int16
bufferSize int
} }
func InitStream(bladeRF *BladeRF, format format.Format, numBuffers int, samplesPerBuffer int, numTransfers int, callback func(data []int16)) *Stream { func InitStream(bladeRF *BladeRF, format format.Format, numBuffers int, samplesPerBuffer int, numTransfers int, callback func(data []int16)) *Stream {
var buffers *unsafe.Pointer var buffers *unsafe.Pointer
var rxStream *C.struct_bladerf_stream var rxStream *C.struct_bladerf_stream
stream := Stream{stream: rxStream} stream := Stream{ref: rxStream}
results := make([]int16, samplesPerBuffer)
cb := Callback{
cb: callback,
results: results,
bufferSize: samplesPerBuffer,
}
C.bladerf_init_stream( C.bladerf_init_stream(
&((stream).stream), &((stream).ref),
(*bladeRF).bladeRF, (*bladeRF).ref,
(*[0]byte)((C.cbGo)), (*[0]byte)((C.StreamCallback)),
&buffers, &buffers,
C.ulong(numBuffers), C.ulong(numBuffers),
C.bladerf_format(format), C.bladerf_format(format),
C.ulong(samplesPerBuffer), C.ulong(samplesPerBuffer),
C.ulong(numTransfers), C.ulong(numTransfers),
pointer.Save(cb), pointer.Save(NewUserData(callback, samplesPerBuffer)),
) )
return &stream return &stream
} }
func DeInitStream(stream *Stream) { func DeInitStream(stream *Stream) {
C.bladerf_deinit_stream(stream.stream) C.bladerf_deinit_stream(stream.ref)
} }
func GetStreamTimeout(bladeRF *BladeRF, direction direction.Direction) (int, error) { func GetStreamTimeout(bladeRF *BladeRF, direction direction.Direction) (int, error) {
var timeout C.uint var timeout C.uint
err := GetError(C.bladerf_get_stream_timeout((*bladeRF).bladeRF, C.bladerf_direction(direction), &timeout)) err := GetError(C.bladerf_get_stream_timeout((*bladeRF).ref, C.bladerf_direction(direction), &timeout))
return int(timeout), err return int(timeout), err
} }
func SetStreamTimeout(bladeRF *BladeRF, direction direction.Direction, timeout int) error { func SetStreamTimeout(bladeRF *BladeRF, direction direction.Direction, timeout int) error {
return GetError(C.bladerf_set_stream_timeout((*bladeRF).bladeRF, 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 channel_layout.ChannelLayout, format format.Format, numBuffers int, bufferSize int, numTransfers int, timeout int) error {
return GetError(C.bladerf_sync_config((*bladeRF).bladeRF, 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 channel_layout.ChannelLayout) error {
return GetError(C.bladerf_stream(stream.stream, C.bladerf_channel_layout(layout))) return GetError(C.bladerf_stream(stream.ref, C.bladerf_channel_layout(layout)))
} }

49
bladerf_test.go
View File

@ -49,11 +49,24 @@ func GetFinalData(input []int16) []complex64 {
return complexFloat return complexFloat
} }
func GetFinalDataString(input []int16) string {
var runes []rune
for i := 0; i < len(input)/2; i++ {
runes = append(runes, rune(input[2*i+1]))
}
return string(runes)
}
func TestBladeRF(t *testing.T) { func TestBladeRF(t *testing.T) {
log.SetVerbosity(log.Debug) log.SetVerbosity(log.Error)
PrintVersion(GetVersion()) PrintVersion(GetVersion())
bootloaders := GetBootloaderList()
fmt.Printf("Bootloaders Len: %d\n", len(bootloaders))
devices := GetDeviceList() devices := GetDeviceList()
fmt.Printf("Devices Len: %d\n", len(devices)) fmt.Printf("Devices Len: %d\n", len(devices))
rf := OpenWithDevInfo(devices[0]) rf := OpenWithDevInfo(devices[0])
@ -80,9 +93,6 @@ func TestBladeRF(t *testing.T) {
rf = Open() rf = Open()
bootloaders := GetBootloaderList()
fmt.Printf("Bootloaders Len: %d\n", len(bootloaders))
err := EnableModule(&rf, CHANNEL_RX(1)) err := EnableModule(&rf, CHANNEL_RX(1))
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
@ -155,7 +165,8 @@ func TestStream(t *testing.T) {
go func() { go func() {
for { for {
out := demodulator.Work(GetFinalData(SyncRX(&rf, audioBufferSize))) data, _ := SyncRX(&rf, audioBufferSize)
out := demodulator.Work(GetFinalData(data))
if out != nil { if out != nil {
var o = out.(demodcore.DemodData) var o = out.(demodcore.DemodData)
@ -220,6 +231,34 @@ func TestGetGainRange(t *testing.T) {
fmt.Println(bfRange.max) fmt.Println(bfRange.max)
} }
func TestGPSData(t *testing.T) {
log.SetVerbosity(log.Debug)
channel := CHANNEL_RX(1)
devices := GetDeviceList()
if len(devices) == 0 {
fmt.Println("NO DEVICE")
return
}
rf := OpenWithDevInfo(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)
for {
data, _ := SyncRX(&rf, audioBufferSize)
out := GetFinalDataString(data)
fmt.Println(out)
}
}
func TestAsyncStream(t *testing.T) { func TestAsyncStream(t *testing.T) {
log.SetVerbosity(log.Debug) log.SetVerbosity(log.Debug)

3
channel/channel.go Normal file
View File

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

9
macros.go
View File

@ -2,11 +2,12 @@ package bladerf
// #include "macro_wrapper.h" // #include "macro_wrapper.h"
import "C" import "C"
import "bladerf/channel"
func CHANNEL_RX(ch int) Channel { func CHANNEL_RX(ch int) channel.Channel {
return Channel(C.ChannelRX(C.int(ch))) return channel.Channel(C.ChannelRX(C.int(ch)))
} }
func CHANNEL_TX(ch int) Channel { func CHANNEL_TX(ch int) channel.Channel {
return Channel(C.ChannelTX(C.int(ch))) return channel.Channel(C.ChannelTX(C.int(ch)))
} }

106
structs.go
View File

@ -3,43 +3,107 @@ package bladerf
// #include <libbladeRF.h> // #include <libbladeRF.h>
import "C" import "C"
import "bladerf/gain_mode" import (
"bladerf/backend"
"bladerf/gain_mode"
)
type DevInfo struct {
ref *C.struct_bladerf_devinfo
backend backend.Backend
serial string
usbBus int8
usbAddr int8
instance uint
manufacturer string
product string
}
func NewDevInfo(ref *C.struct_bladerf_devinfo) DevInfo {
devInfo := DevInfo{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 devInfo.ref.manufacturer {
if devInfo.ref.manufacturer[i] != 0 {
manufacturer = append(manufacturer, rune(devInfo.ref.manufacturer[i]))
}
}
for i := range devInfo.ref.product {
if devInfo.ref.product[i] != 0 {
product = append(product, rune(devInfo.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)
return devInfo
}
type Version struct { type Version struct {
version *C.struct_bladerf_version ref *C.struct_bladerf_version
major int major uint16
minor int minor uint16
patch int patch uint16
describe string describe string
} }
type DevInfo struct {
devInfo *C.struct_bladerf_devinfo
serial string
}
type Range struct { type Range struct {
bfRange *C.struct_bladerf_range ref *C.struct_bladerf_range
min int64 min int64
max int64 max int64
step int64 step int64
scale float64 scale float64
} }
type BladeRF struct { type BladeRF struct {
bladeRF *C.struct_bladerf ref *C.struct_bladerf
} }
type Module struct { type Module struct {
module *C.struct_bladerf_module ref *C.struct_bladerf_module
} }
type Stream struct { type Stream struct {
stream *C.struct_bladerf_stream ref *C.struct_bladerf_stream
} }
type GainModes struct { type GainModes struct {
gainModes *C.struct_bladerf_gain_modes ref *C.struct_bladerf_gain_modes
name string name string
mode gain_mode.GainMode mode gain_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)
return gainModes
}
type UserData struct {
callback func(data []int16)
results []int16
bufferSize int
}
func NewUserData(callback func(data []int16), bufferSize int) UserData {
return UserData{callback: callback, results: make([]int16, bufferSize), bufferSize: bufferSize}
} }