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

View File

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

View File

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

3
channel/channel.go Normal file
View File

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

View File

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

View File

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