go-bladerf/bladerf.go

package bladerf

func StreamCallback(
	fmt.Printf("v%d.%d.%d (\"%s\")", version.Major, version.Minor, version.Patch, version.Describe)
return 0, err

	if err != nil {
		return Version{}, err
	}

	return NewVersion(&version), nil

	var actual C.uint
	var sampleRate C.uint
		&actual),
	var gain C.bladerf_gain

	}
}

	}

	return GetError(C.bladerf_trim_dac_write(bladeRF.ref, C.uint16_t(val)))
}
	var val C.uint32_t
	err := GetError(C.bladerf_config_gpio_read(bladeRF.ref, &val))

	if err != nil {
		return 0, err
	}

	return uint32(val), nil
}

func (bladeRF *BladeRF) ConfigGpioWrite(val uint32) error {
	return GetError(C.bladerf_config_gpio_write(bladeRF.ref, C.uint32_t(val)))
}

func (bladeRF *BladeRF) EraseFlash(eraseBlock uint32, count uint32) error {
	return GetError(C.bladerf_erase_flash(bladeRF.ref, C.uint32_t(eraseBlock), C.uint32_t(count)))
}

func (bladeRF *BladeRF) EraseFlashBytes(address uint32, length uint32) error {
	return GetError(C.bladerf_erase_flash_bytes(bladeRF.ref, C.uint32_t(address), C.uint32_t(length)))
}

func (bladeRF *BladeRF) LockOtp() error {
	return GetError(C.bladerf_lock_otp(bladeRF.ref))
}

	defer C.free(unsafe.Pointer(buf))

	for i := uint32(0); i < bytes/C.sizeof_uint8_t; i++ {
		addr := (*C.uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(buf)) + (C.sizeof_uint8_t * uintptr(i))))
		*addr = (C.uint8_t)(input[i])
	}

	return GetError(C.bladerf_write_flash_bytes(bladeRF.ref, buf, C.uint32_t(address), C.uint32_t(bytes)))

			return string(port), nil
					finish = true
					ports = append(ports, string(port))
				}

				offset++
			}
		}
	}

	return ports, nil
}