enums.go

package hackrf

// #include <libhackrf/hackrf.h>
import "C"

import "strconv"

// BoardID identifies the type of HackRF board (enum hackrf_board_id), as
// returned by Device.BoardIDRead.
type BoardID uint8

const (
	BoardIDJellybean    BoardID = C.BOARD_ID_JELLYBEAN
	BoardIDJawbreaker   BoardID = C.BOARD_ID_JAWBREAKER
	BoardIDHackRF1OG    BoardID = C.BOARD_ID_HACKRF1_OG
	BoardIDRad1o        BoardID = C.BOARD_ID_RAD1O
	BoardIDHackRF1R9    BoardID = C.BOARD_ID_HACKRF1_R9
	BoardIDPraline      BoardID = C.BOARD_ID_PRALINE
	BoardIDUnrecognized BoardID = C.BOARD_ID_UNRECOGNIZED
	BoardIDUndetected   BoardID = C.BOARD_ID_UNDETECTED

	// Deprecated aliases kept for API compatibility with hackrf.h.
	BoardIDHackRFOne BoardID = C.BOARD_ID_HACKRF_ONE
	BoardIDInvalid   BoardID = C.BOARD_ID_INVALID
)

// String returns the human-readable board name (hackrf_board_id_name).
func (b BoardID) String() string {
	return C.GoString(C.hackrf_board_id_name(C.enum_hackrf_board_id(b)))
}

// Platform returns the platform bitfield (HACKRF_PLATFORM_*) for the board id
// (hackrf_board_id_platform).
func (b BoardID) Platform() uint32 {
	return uint32(C.hackrf_board_id_platform(C.enum_hackrf_board_id(b)))
}

// BoardRev identifies a HackRF board revision (enum hackrf_board_rev), as
// returned by Device.BoardRevRead. The most significant bit (BoardRevGSG)
// indicates a board built by Great Scott Gadgets.
type BoardRev uint8

const (
	BoardRevHackRF1Old BoardRev = C.BOARD_REV_HACKRF1_OLD
	BoardRevHackRF1R6  BoardRev = C.BOARD_REV_HACKRF1_R6
	BoardRevHackRF1R7  BoardRev = C.BOARD_REV_HACKRF1_R7
	BoardRevHackRF1R8  BoardRev = C.BOARD_REV_HACKRF1_R8
	BoardRevHackRF1R9  BoardRev = C.BOARD_REV_HACKRF1_R9
	BoardRevHackRF1R10 BoardRev = C.BOARD_REV_HACKRF1_R10

	BoardRevPralineR0_1 BoardRev = C.BOARD_REV_PRALINE_R0_1
	BoardRevPralineR0_2 BoardRev = C.BOARD_REV_PRALINE_R0_2
	BoardRevPralineR0_3 BoardRev = C.BOARD_REV_PRALINE_R0_3
	BoardRevPralineR1_0 BoardRev = C.BOARD_REV_PRALINE_R1_0
	BoardRevPralineR1_1 BoardRev = C.BOARD_REV_PRALINE_R1_1
	BoardRevPralineR1_2 BoardRev = C.BOARD_REV_PRALINE_R1_2

	BoardRevGSGHackRF1R6  BoardRev = C.BOARD_REV_GSG_HACKRF1_R6
	BoardRevGSGHackRF1R7  BoardRev = C.BOARD_REV_GSG_HACKRF1_R7
	BoardRevGSGHackRF1R8  BoardRev = C.BOARD_REV_GSG_HACKRF1_R8
	BoardRevGSGHackRF1R9  BoardRev = C.BOARD_REV_GSG_HACKRF1_R9
	BoardRevGSGHackRF1R10 BoardRev = C.BOARD_REV_GSG_HACKRF1_R10

	BoardRevGSGPralineR0_1 BoardRev = C.BOARD_REV_GSG_PRALINE_R0_1
	BoardRevGSGPralineR0_2 BoardRev = C.BOARD_REV_GSG_PRALINE_R0_2
	BoardRevGSGPralineR0_3 BoardRev = C.BOARD_REV_GSG_PRALINE_R0_3
	BoardRevGSGPralineR1_0 BoardRev = C.BOARD_REV_GSG_PRALINE_R1_0
	BoardRevGSGPralineR1_1 BoardRev = C.BOARD_REV_GSG_PRALINE_R1_1
	BoardRevGSGPralineR1_2 BoardRev = C.BOARD_REV_GSG_PRALINE_R1_2

	BoardRevUnrecognized BoardRev = C.BOARD_REV_UNRECOGNIZED
	BoardRevUndetected   BoardRev = C.BOARD_REV_UNDETECTED
)

// String returns the human-readable board revision name
// (hackrf_board_rev_name). The GSG bit is ignored by libhackrf when forming
// the name.
func (r BoardRev) String() string {
	return C.GoString(C.hackrf_board_rev_name(C.enum_hackrf_board_rev(r)))
}

// IsGSG reports whether the revision was built by Great Scott Gadgets.
func (r BoardRev) IsGSG() bool { return r&BoardRevGSG != 0 }

// USBBoardID is a USB-IF product ID (enum hackrf_usb_board_id), used in a
// DeviceList entry to identify hardware without opening the device.
type USBBoardID uint16

const (
	USBBoardIDJawbreaker USBBoardID = C.USB_BOARD_ID_JAWBREAKER
	USBBoardIDHackRFOne  USBBoardID = C.USB_BOARD_ID_HACKRF_ONE
	USBBoardIDRad1o      USBBoardID = C.USB_BOARD_ID_RAD1O
	USBBoardIDInvalid    USBBoardID = C.USB_BOARD_ID_INVALID
)

// String returns the human-readable USB board name (hackrf_usb_board_id_name).
func (u USBBoardID) String() string {
	return C.GoString(C.hackrf_usb_board_id_name(C.enum_hackrf_usb_board_id(u)))
}

// RFPathFilter selects the image-rejection filter / mixer path for explicit
// tuning (enum rf_path_filter). See Device.SetFreqExplicit.
type RFPathFilter int

const (
	// RFPathFilterBypass bypasses the mixer; f_center = f_IF.
	RFPathFilterBypass RFPathFilter = C.RF_PATH_FILTER_BYPASS
	// RFPathFilterLowPass selects the LPF; f_center = f_IF - f_LO.
	RFPathFilterLowPass RFPathFilter = C.RF_PATH_FILTER_LOW_PASS
	// RFPathFilterHighPass selects the HPF; f_center = f_IF + f_LO.
	RFPathFilterHighPass RFPathFilter = C.RF_PATH_FILTER_HIGH_PASS
)

// String returns the human-readable filter path name (hackrf_filter_path_name).
func (p RFPathFilter) String() string {
	return C.GoString(C.hackrf_filter_path_name(C.enum_rf_path_filter(p)))
}

// OperacakePort identifies an Opera Cake secondary port (enum operacake_ports).
type OperacakePort uint8

const (
	OperacakePA1 OperacakePort = C.OPERACAKE_PA1
	OperacakePA2 OperacakePort = C.OPERACAKE_PA2
	OperacakePA3 OperacakePort = C.OPERACAKE_PA3
	OperacakePA4 OperacakePort = C.OPERACAKE_PA4
	OperacakePB1 OperacakePort = C.OPERACAKE_PB1
	OperacakePB2 OperacakePort = C.OPERACAKE_PB2
	OperacakePB3 OperacakePort = C.OPERACAKE_PB3
	OperacakePB4 OperacakePort = C.OPERACAKE_PB4
)

func (p OperacakePort) String() string {
	switch p {
	case OperacakePA1:
		return "A1"
	case OperacakePA2:
		return "A2"
	case OperacakePA3:
		return "A3"
	case OperacakePA4:
		return "A4"
	case OperacakePB1:
		return "B1"
	case OperacakePB2:
		return "B2"
	case OperacakePB3:
		return "B3"
	case OperacakePB4:
		return "B4"
	default:
		return "OperacakePort(" + strconv.Itoa(int(p)) + ")"
	}
}

// OperacakeSwitchingMode is an Opera Cake port-switching mode
// (enum operacake_switching_mode). See Device.SetOperacakeMode.
type OperacakeSwitchingMode int

const (
	OperacakeModeManual    OperacakeSwitchingMode = C.OPERACAKE_MODE_MANUAL
	OperacakeModeFrequency OperacakeSwitchingMode = C.OPERACAKE_MODE_FREQUENCY
	OperacakeModeTime      OperacakeSwitchingMode = C.OPERACAKE_MODE_TIME
)

func (m OperacakeSwitchingMode) String() string {
	switch m {
	case OperacakeModeManual:
		return "manual"
	case OperacakeModeFrequency:
		return "frequency"
	case OperacakeModeTime:
		return "time"
	default:
		return "OperacakeSwitchingMode(" + strconv.Itoa(int(m)) + ")"
	}
}

// SweepStyle selects the sweep stepping behavior (enum sweep_style). See
// Device.InitSweep.
type SweepStyle int

const (
	// SweepStyleLinear adds step_width to the current frequency at each step.
	SweepStyleLinear SweepStyle = C.LINEAR
	// SweepStyleInterleaved divides each step into two interleaved sub-steps.
	SweepStyleInterleaved SweepStyle = C.INTERLEAVED
)

func (s SweepStyle) String() string {
	switch s {
	case SweepStyleLinear:
		return "linear"
	case SweepStyleInterleaved:
		return "interleaved"
	default:
		return "SweepStyle(" + strconv.Itoa(int(s)) + ")"
	}
}

// P1CtrlSignal selects the signal routed to the HackRF Pro P1 SMA connector
// (enum p1_ctrl_signal). See Device.SetP1Ctrl.
type P1CtrlSignal int

const (
	P1SignalTriggerIn  P1CtrlSignal = C.P1_SIGNAL_TRIGGER_IN
	P1SignalAuxClk1    P1CtrlSignal = C.P1_SIGNAL_AUX_CLK1
	P1SignalClkin      P1CtrlSignal = C.P1_SIGNAL_CLKIN
	P1SignalTriggerOut P1CtrlSignal = C.P1_SIGNAL_TRIGGER_OUT
	P1SignalP22Clkin   P1CtrlSignal = C.P1_SIGNAL_P22_CLKIN
	P1SignalP2_5       P1CtrlSignal = C.P1_SIGNAL_P2_5
	P1SignalNC         P1CtrlSignal = C.P1_SIGNAL_NC
	P1SignalAuxClk2    P1CtrlSignal = C.P1_SIGNAL_AUX_CLK2
)

// P2CtrlSignal selects the signal routed to the HackRF Pro P2 SMA connector
// (enum p2_ctrl_signal). See Device.SetP2Ctrl.
type P2CtrlSignal int

const (
	P2SignalClk3       P2CtrlSignal = C.P2_SIGNAL_CLK3
	P2SignalTriggerIn  P2CtrlSignal = C.P2_SIGNAL_TRIGGER_IN
	P2SignalTriggerOut P2CtrlSignal = C.P2_SIGNAL_TRIGGER_OUT
)

// ClkinCtrlSignal selects the HackRF Pro clock input source (enum
// clkin_ctrl_signal). See Device.SetClkinCtrl.
type ClkinCtrlSignal int

const (
	ClkinSignalP1  ClkinCtrlSignal = C.CLKIN_SIGNAL_P1
	ClkinSignalP22 ClkinCtrlSignal = C.CLKIN_SIGNAL_P22
)