diff --git a/bladerf.go b/bladerf.go index b3e223d..74dcb64 100644 --- a/bladerf.go +++ b/bladerf.go @@ -7,9 +7,10 @@ import "C" // #cgo LDFLAGS: -lbladeRF // #include // -// 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))) } diff --git a/bladerf_test.go b/bladerf_test.go index 430a59e..68685de 100644 --- a/bladerf_test.go +++ b/bladerf_test.go @@ -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) diff --git a/channel/channel.go b/channel/channel.go new file mode 100644 index 0000000..e9feb20 --- /dev/null +++ b/channel/channel.go @@ -0,0 +1,3 @@ +package channel + +type Channel int diff --git a/macros.go b/macros.go index 1f43e99..86ddd0f 100644 --- a/macros.go +++ b/macros.go @@ -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))) } diff --git a/structs.go b/structs.go index 371e850..d9209af 100644 --- a/structs.go +++ b/structs.go @@ -3,43 +3,107 @@ package bladerf // #include 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} }