some shits
This commit is contained in:
parent
024dc212d4
commit
8d2c0fa989
322
bladerf.go
322
bladerf.go
|
@ -7,9 +7,10 @@ import "C"
|
|||
// #cgo LDFLAGS: -lbladeRF
|
||||
// #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 (
|
||||
"bladerf/channel"
|
||||
"bladerf/channel_layout"
|
||||
"bladerf/direction"
|
||||
exception "bladerf/error"
|
||||
|
@ -25,60 +26,42 @@ func GetError(code C.int) error {
|
|||
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)
|
||||
|
||||
//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))))))
|
||||
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))))))
|
||||
}
|
||||
|
||||
cb.cb(cb.results)
|
||||
|
||||
return samples // C.malloc(C.size_t(size * cb.bufferSize * 2 * 1)) allocate always fcjinf new
|
||||
ud.callback(ud.results)
|
||||
return samples
|
||||
}
|
||||
|
||||
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 {
|
||||
var version C.struct_bladerf_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) {
|
||||
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)
|
||||
defer C.free(unsafe.Pointer(path))
|
||||
|
||||
C.bladerf_load_fpga(bladeRF.bladeRF, path)
|
||||
return GetError(C.bladerf_load_fpga(bladeRF.ref, path))
|
||||
}
|
||||
|
||||
func FreeDeviceList(devInfo DevInfo) {
|
||||
C.bladerf_free_device_list(devInfo.devInfo)
|
||||
C.bladerf_free_device_list(devInfo.ref)
|
||||
}
|
||||
|
||||
func GetDeviceList() []DevInfo {
|
||||
|
@ -87,20 +70,16 @@ func GetDeviceList() []DevInfo {
|
|||
|
||||
count := int(C.bladerf_get_device_list(&devInfo))
|
||||
|
||||
if count < 1 {
|
||||
return devices
|
||||
}
|
||||
|
||||
first := DevInfo{devInfo: devInfo}
|
||||
|
||||
defer FreeDeviceList(first)
|
||||
|
||||
devices = append(devices, first)
|
||||
|
||||
for i := 0; i < count-1; i++ {
|
||||
if count > 0 {
|
||||
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
|
||||
|
@ -112,20 +91,16 @@ func GetBootloaderList() []DevInfo {
|
|||
|
||||
count := int(C.bladerf_get_bootloader_list(&devInfo))
|
||||
|
||||
if count < 1 {
|
||||
return devices
|
||||
}
|
||||
|
||||
first := DevInfo{devInfo: devInfo}
|
||||
|
||||
defer FreeDeviceList(first)
|
||||
|
||||
devices = append(devices, first)
|
||||
|
||||
for i := 0; i < count-1; i++ {
|
||||
if count > 0 {
|
||||
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
|
||||
|
@ -134,75 +109,66 @@ func GetBootloaderList() []DevInfo {
|
|||
func InitDevInfo() DevInfo {
|
||||
var devInfo C.struct_bladerf_devinfo
|
||||
C.bladerf_init_devinfo(&devInfo)
|
||||
return DevInfo{devInfo: &devInfo}
|
||||
return NewDevInfo(&devInfo)
|
||||
}
|
||||
|
||||
func GetDevInfo(bladeRF *BladeRF) DevInfo {
|
||||
var devInfo C.struct_bladerf_devinfo
|
||||
C.bladerf_get_devinfo((*bladeRF).bladeRF, &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
|
||||
C.bladerf_get_devinfo((*bladeRF).ref, &devInfo)
|
||||
return NewDevInfo(&devInfo)
|
||||
}
|
||||
|
||||
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 {
|
||||
val := C.CString(devstr)
|
||||
func DevStrMatches(devStr string, info DevInfo) bool {
|
||||
val := C.CString(devStr)
|
||||
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 {
|
||||
val := C.CString(devstr)
|
||||
func GetDevInfoFromStr(devStr string) DevInfo {
|
||||
val := C.CString(devStr)
|
||||
defer C.free(unsafe.Pointer(val))
|
||||
var devInfo C.struct_bladerf_devinfo
|
||||
C.bladerf_get_devinfo_from_str(val, &devInfo)
|
||||
return DevInfo{devInfo: &devInfo}
|
||||
return NewDevInfo(&devInfo)
|
||||
}
|
||||
|
||||
func OpenWithDevInfo(devInfo DevInfo) BladeRF {
|
||||
var bladeRF *C.struct_bladerf
|
||||
C.bladerf_open_with_devinfo(&bladeRF, devInfo.devInfo)
|
||||
return BladeRF{bladeRF: bladeRF}
|
||||
C.bladerf_open_with_devinfo(&bladeRF, devInfo.ref)
|
||||
return BladeRF{ref: bladeRF}
|
||||
}
|
||||
|
||||
func OpenWithDeviceIdentifier(identify string) BladeRF {
|
||||
var bladeRF *C.struct_bladerf
|
||||
C.bladerf_open(&bladeRF, C.CString(identify))
|
||||
return BladeRF{bladeRF: bladeRF}
|
||||
return BladeRF{ref: bladeRF}
|
||||
}
|
||||
|
||||
func Open() BladeRF {
|
||||
var bladeRF *C.struct_bladerf
|
||||
C.bladerf_open(&bladeRF, nil)
|
||||
return BladeRF{bladeRF: bladeRF}
|
||||
return BladeRF{ref: bladeRF}
|
||||
}
|
||||
|
||||
func Close(bladeRF BladeRF) {
|
||||
C.bladerf_close(bladeRF.bladeRF)
|
||||
C.bladerf_close(bladeRF.ref)
|
||||
}
|
||||
|
||||
func SetLoopback(bladeRF *BladeRF, loopback loopback.Loopback) {
|
||||
C.bladerf_set_loopback((*bladeRF).bladeRF, C.bladerf_loopback(loopback))
|
||||
func SetLoopback(bladeRF *BladeRF, loopback loopback.Loopback) error {
|
||||
return GetError(C.bladerf_set_loopback((*bladeRF).ref, C.bladerf_loopback(loopback)))
|
||||
}
|
||||
|
||||
func SetFrequency(bladeRF *BladeRF, channel Channel, frequency int) error {
|
||||
return GetError(C.bladerf_set_frequency((*bladeRF).bladeRF, C.bladerf_channel(channel), C.ulonglong(frequency)))
|
||||
func SetFrequency(bladeRF *BladeRF, channel channel.Channel, frequency int) error {
|
||||
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
|
||||
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 {
|
||||
println(uint(actual))
|
||||
|
@ -211,10 +177,10 @@ func SetSampleRate(bladeRF *BladeRF, channel Channel, sampleRate int) error {
|
|||
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
|
||||
|
||||
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 {
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
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 {
|
||||
return GetError(C.bladerf_set_gain((*bladeRF).bladeRF, C.bladerf_channel(channel), C.int(gain)))
|
||||
func SetGain(bladeRF *BladeRF, channel channel.Channel, gain int) error {
|
||||
return GetError(C.bladerf_set_gain((*bladeRF).ref, C.bladerf_channel(channel), C.int(gain)))
|
||||
}
|
||||
|
||||
func GetGain(bladeRF *BladeRF, channel Channel) (int, error) {
|
||||
func GetGain(bladeRF *BladeRF, channel channel.Channel) (int, error) {
|
||||
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 {
|
||||
return int(gain), nil
|
||||
}
|
||||
|
@ -242,11 +208,11 @@ func GetGain(bladeRF *BladeRF, channel Channel) (int, error) {
|
|||
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)
|
||||
defer C.free(unsafe.Pointer(val))
|
||||
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 {
|
||||
return int(gain), nil
|
||||
}
|
||||
|
@ -254,10 +220,10 @@ func GetGainStage(bladeRF *BladeRF, channel Channel, stage string) (int, error)
|
|||
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
|
||||
|
||||
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))
|
||||
if err == nil {
|
||||
return result, nil
|
||||
|
@ -266,52 +232,52 @@ func GetGainMode(bladeRF *BladeRF, channel Channel) (gain_mode.GainMode, error)
|
|||
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)
|
||||
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
|
||||
val := C.CString(stage)
|
||||
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 {
|
||||
return Range{
|
||||
bfRange: bfRange,
|
||||
min: int64(bfRange.min),
|
||||
max: int64(bfRange.max),
|
||||
step: int64(bfRange.step),
|
||||
scale: float64(bfRange.scale),
|
||||
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) (Range, error) {
|
||||
func GetGainRange(bladeRF *BladeRF, channel channel.Channel) (Range, error) {
|
||||
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 {
|
||||
return Range{
|
||||
bfRange: bfRange,
|
||||
min: int64(bfRange.min),
|
||||
max: int64(bfRange.max),
|
||||
step: int64(bfRange.step),
|
||||
scale: float64(bfRange.scale),
|
||||
ref: bfRange,
|
||||
min: int64(bfRange.min),
|
||||
max: int64(bfRange.max),
|
||||
step: int64(bfRange.step),
|
||||
scale: float64(bfRange.scale),
|
||||
}, nil
|
||||
}
|
||||
|
||||
return Range{}, err
|
||||
}
|
||||
|
||||
func GetNumberOfGainStages(bladeRF *BladeRF, channel Channel) int {
|
||||
count := int(C.bladerf_get_gain_stages((*bladeRF).bladeRF, C.bladerf_channel(channel), nil, 0))
|
||||
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
|
||||
|
@ -320,150 +286,122 @@ func GetNumberOfGainStages(bladeRF *BladeRF, channel Channel) int {
|
|||
return count
|
||||
}
|
||||
|
||||
func GetGainStages(bladeRF *BladeRF, channel Channel) []string {
|
||||
func GetGainStages(bladeRF *BladeRF, channel channel.Channel) []string {
|
||||
var stage *C.char
|
||||
var stages []string
|
||||
|
||||
count := int(C.bladerf_get_gain_stages(
|
||||
(*bladeRF).bladeRF,
|
||||
(*bladeRF).ref,
|
||||
C.bladerf_channel(channel),
|
||||
&stage,
|
||||
C.ulong(GetNumberOfGainStages(bladeRF, channel))),
|
||||
)
|
||||
|
||||
if count < 1 {
|
||||
return stages
|
||||
}
|
||||
|
||||
first := C.GoString(stage)
|
||||
stages = append(stages, first)
|
||||
|
||||
for i := 0; i < count-1; i++ {
|
||||
if count > 0 {
|
||||
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
|
||||
}
|
||||
|
||||
func GetGainModes(bladeRF *BladeRF, channel Channel) []GainModes {
|
||||
func GetGainModes(bladeRF *BladeRF, channel channel.Channel) []GainModes {
|
||||
var gainMode *C.struct_bladerf_gain_modes
|
||||
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 {
|
||||
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++ {
|
||||
if count > 0 {
|
||||
size := unsafe.Sizeof(*gainMode)
|
||||
gainMode = (*C.struct_bladerf_gain_modes)(unsafe.Pointer(uintptr(unsafe.Pointer(gainMode)) + size))
|
||||
gainModes = append(gainModes, GainModes{
|
||||
gainModes: gainMode,
|
||||
name: C.GoString(gainMode.name),
|
||||
mode: gain_mode.GainMode(gainMode.mode),
|
||||
})
|
||||
|
||||
for i := 0; i < count; i++ {
|
||||
gainModes = append(gainModes, NewGainModes(
|
||||
(*C.struct_bladerf_gain_modes)(unsafe.Pointer(uintptr(unsafe.Pointer(gainMode))+(uintptr(i)*size))),
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
return gainModes
|
||||
}
|
||||
|
||||
func SetGainMode(bladeRF *BladeRF, 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)))
|
||||
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 EnableModule(bladeRF *BladeRF, channel Channel) error {
|
||||
return GetError(C.bladerf_enable_module((*bladeRF).bladeRF, C.bladerf_channel(channel), true))
|
||||
func EnableModule(bladeRF *BladeRF, channel channel.Channel) error {
|
||||
return GetError(C.bladerf_enable_module((*bladeRF).ref, C.bladerf_channel(channel), true))
|
||||
}
|
||||
|
||||
func DisableModule(bladeRF *BladeRF, channel Channel) error {
|
||||
return GetError(C.bladerf_enable_module((*bladeRF).bladeRF, C.bladerf_channel(channel), false))
|
||||
func DisableModule(bladeRF *BladeRF, channel channel.Channel) error {
|
||||
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
|
||||
|
||||
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 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 {
|
||||
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))
|
||||
}
|
||||
} else {
|
||||
fmt.Printf("Failed to RX samples: %s", err)
|
||||
|
||||
return results, nil
|
||||
}
|
||||
|
||||
return results
|
||||
}
|
||||
|
||||
type Callback struct {
|
||||
cb func(data []int16)
|
||||
results []int16
|
||||
bufferSize int
|
||||
return nil, err
|
||||
}
|
||||
|
||||
func InitStream(bladeRF *BladeRF, format format.Format, numBuffers int, samplesPerBuffer int, numTransfers int, callback func(data []int16)) *Stream {
|
||||
var buffers *unsafe.Pointer
|
||||
var rxStream *C.struct_bladerf_stream
|
||||
|
||||
stream := Stream{stream: rxStream}
|
||||
|
||||
results := make([]int16, samplesPerBuffer)
|
||||
|
||||
cb := Callback{
|
||||
cb: callback,
|
||||
results: results,
|
||||
bufferSize: samplesPerBuffer,
|
||||
}
|
||||
stream := Stream{ref: rxStream}
|
||||
|
||||
C.bladerf_init_stream(
|
||||
&((stream).stream),
|
||||
(*bladeRF).bladeRF,
|
||||
(*[0]byte)((C.cbGo)),
|
||||
&((stream).ref),
|
||||
(*bladeRF).ref,
|
||||
(*[0]byte)((C.StreamCallback)),
|
||||
&buffers,
|
||||
C.ulong(numBuffers),
|
||||
C.bladerf_format(format),
|
||||
C.ulong(samplesPerBuffer),
|
||||
C.ulong(numTransfers),
|
||||
pointer.Save(cb),
|
||||
pointer.Save(NewUserData(callback, samplesPerBuffer)),
|
||||
)
|
||||
|
||||
return &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) {
|
||||
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
|
||||
}
|
||||
|
||||
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 {
|
||||
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 {
|
||||
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,11 +49,24 @@ func GetFinalData(input []int16) []complex64 {
|
|||
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) {
|
||||
log.SetVerbosity(log.Debug)
|
||||
log.SetVerbosity(log.Error)
|
||||
|
||||
PrintVersion(GetVersion())
|
||||
|
||||
bootloaders := GetBootloaderList()
|
||||
fmt.Printf("Bootloaders Len: %d\n", len(bootloaders))
|
||||
|
||||
devices := GetDeviceList()
|
||||
fmt.Printf("Devices Len: %d\n", len(devices))
|
||||
rf := OpenWithDevInfo(devices[0])
|
||||
|
@ -80,9 +93,6 @@ func TestBladeRF(t *testing.T) {
|
|||
|
||||
rf = Open()
|
||||
|
||||
bootloaders := GetBootloaderList()
|
||||
fmt.Printf("Bootloaders Len: %d\n", len(bootloaders))
|
||||
|
||||
err := EnableModule(&rf, CHANNEL_RX(1))
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
|
@ -155,7 +165,8 @@ func TestStream(t *testing.T) {
|
|||
|
||||
go func() {
|
||||
for {
|
||||
out := demodulator.Work(GetFinalData(SyncRX(&rf, audioBufferSize)))
|
||||
data, _ := SyncRX(&rf, audioBufferSize)
|
||||
out := demodulator.Work(GetFinalData(data))
|
||||
|
||||
if out != nil {
|
||||
var o = out.(demodcore.DemodData)
|
||||
|
@ -220,6 +231,34 @@ func TestGetGainRange(t *testing.T) {
|
|||
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) {
|
||||
log.SetVerbosity(log.Debug)
|
||||
|
||||
|
|
|
@ -0,0 +1,3 @@
|
|||
package channel
|
||||
|
||||
type Channel int
|
|
@ -2,11 +2,12 @@ package bladerf
|
|||
|
||||
// #include "macro_wrapper.h"
|
||||
import "C"
|
||||
import "bladerf/channel"
|
||||
|
||||
func CHANNEL_RX(ch int) Channel {
|
||||
return Channel(C.ChannelRX(C.int(ch)))
|
||||
func CHANNEL_RX(ch int) channel.Channel {
|
||||
return channel.Channel(C.ChannelRX(C.int(ch)))
|
||||
}
|
||||
|
||||
func CHANNEL_TX(ch int) Channel {
|
||||
return Channel(C.ChannelTX(C.int(ch)))
|
||||
func CHANNEL_TX(ch int) channel.Channel {
|
||||
return channel.Channel(C.ChannelTX(C.int(ch)))
|
||||
}
|
||||
|
|
106
structs.go
106
structs.go
|
@ -3,43 +3,107 @@ package bladerf
|
|||
// #include <libbladeRF.h>
|
||||
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 {
|
||||
version *C.struct_bladerf_version
|
||||
major int
|
||||
minor int
|
||||
patch int
|
||||
ref *C.struct_bladerf_version
|
||||
major uint16
|
||||
minor uint16
|
||||
patch uint16
|
||||
describe string
|
||||
}
|
||||
|
||||
type DevInfo struct {
|
||||
devInfo *C.struct_bladerf_devinfo
|
||||
serial string
|
||||
}
|
||||
|
||||
type Range struct {
|
||||
bfRange *C.struct_bladerf_range
|
||||
min int64
|
||||
max int64
|
||||
step int64
|
||||
scale float64
|
||||
ref *C.struct_bladerf_range
|
||||
min int64
|
||||
max int64
|
||||
step int64
|
||||
scale float64
|
||||
}
|
||||
|
||||
type BladeRF struct {
|
||||
bladeRF *C.struct_bladerf
|
||||
ref *C.struct_bladerf
|
||||
}
|
||||
|
||||
type Module struct {
|
||||
module *C.struct_bladerf_module
|
||||
ref *C.struct_bladerf_module
|
||||
}
|
||||
|
||||
type Stream struct {
|
||||
stream *C.struct_bladerf_stream
|
||||
ref *C.struct_bladerf_stream
|
||||
}
|
||||
|
||||
type GainModes struct {
|
||||
gainModes *C.struct_bladerf_gain_modes
|
||||
name string
|
||||
mode gain_mode.GainMode
|
||||
ref *C.struct_bladerf_gain_modes
|
||||
name string
|
||||
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}
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue