HackRFSource::HackRFSource(std::string args,
uint32_t sampleRate,
uint32_t sampleCount,
double startFrequency,
double stopFrequency)
: SignalSource(sampleRate, sampleCount, startFrequency, stopFrequency, 0.75, 0.0),
m_dev(nullptr),
m_streamingState(Illegal),
m_nextValidStreamTime{0, 0},
m_retuneTime(0.0100),
m_dropPacketCount(0), // ceil(sampleRate * m_retuneTime / 131072)),
m_scanStartCount(101),
m_centerFrequency(1e12),
m_didRetune(false)
{
int status;
status = hackrf_init();
HANDLE_ERROR("hackrf_init() failed: %%s\n");
status = hackrf_open( &this->m_dev );
HANDLE_ERROR("Failed to open HackRF device: %%s\n");
uint8_t board_id;
status = hackrf_board_id_read( this->m_dev, &board_id );
HANDLE_ERROR("Failed to get HackRF board id: %%s\n");
char version[128];
memset(version, 0, sizeof(version));
status = hackrf_version_string_read( this->m_dev, version, sizeof(version));
HANDLE_ERROR("Failed to read version string: %%s\n");
this->set_sample_rate(sampleRate);
uint32_t bandWidth = hackrf_compute_baseband_filter_bw(uint32_t(0.75 * sampleRate));
status = hackrf_set_baseband_filter_bandwidth( this->m_dev, bandWidth );
HANDLE_ERROR("hackrf_set_baseband_filter_bandwidth %u: %%s", bandWidth );
/* range 0-40 step 8d, IF gain in osmosdr */
hackrf_set_lna_gain(this->m_dev, 24);
/* range 0-62 step 2db, BB gain in osmosdr */
hackrf_set_vga_gain(this->m_dev, 28);
/* Disable AMP gain stage by default. */
hackrf_set_amp_enable(this->m_dev, 0);
status = hackrf_set_antenna_enable(this->m_dev, 0);
if (args.find("bias")) {
/* antenna port power control */
status = hackrf_set_antenna_enable(this->m_dev, 1);
HANDLE_ERROR("Failed to enable antenna DC bias: %%s\n");
}
double startFrequency1 = this->GetStartFrequency();
this->Retune(startFrequency1);
double stopFrequency1 = this->GetStopFrequency();
// This was my firmware sweep implementation. But Michael Ossmann has provided
// new firmware API that sweeps much faster.
#if 0
status = hackrf_set_scan_parameters(this->m_dev,
uint64_t(startFrequency1),
uint64_t(stopFrequency1),
uint32_t(0.75 * sampleRate));
printf("Setting scan parameters: [%lu %lu %u]\n",
uint64_t(startFrequency1),
uint64_t(stopFrequency1),
uint32_t(0.75 * sampleRate));
HANDLE_ERROR("Failed to set scan parameters: %%s\n");
#endif
// Store scan parameters to use later.
this->m_scanStartFrequency = uint16_t(startFrequency/1e6);
this->m_scanStopFrequency = uint16_t(stopFrequency/1e6);
this->m_scanNumBytes = sampleCount*2;
this->m_scanStepWidth = 0.75 * sampleRate;
this->m_scanOffset = this->m_scanStepWidth/2.0;
}
/* Entry point to C/C++ */
void mexFunction(int nlhs,mxArray *plhs[],int nrhs,const mxArray *prhs[])
{
int result =HACKRF_SUCCESS,i;
struct hackrf_device *_device [10];
hackrf_device_list_t *list;
uint8_t board_id = BOARD_ID_INVALID;
char version[255 + 1];
read_partid_serialno_t read_partid_serialno;
result = hackrf_init();
if (result != HACKRF_SUCCESS) {
mexPrintf("hackrf_init() failed: %s (%d)\n",hackrf_error_name((hackrf_error)result), result);
}
list = hackrf_device_list();
if (list->devicecount < 1 ) {
mexPrintf("No HackRF boards found.\n");
}
for (i = 0; i < list->devicecount; i++){
mexPrintf("Found HackRF board %d:\n", i);
if (list->serial_numbers[i])
mexPrintf("USB descriptor string: %s\n", list->serial_numbers[i]);
result = hackrf_device_list_open(list, i, &_device [i]);
if (result != HACKRF_SUCCESS) {
mexPrintf("hackrf_open() failed: %s (%d)\n",hackrf_error_name((hackrf_error)result), result);
}
result = hackrf_board_id_read(_device[i], &board_id);
if (result != HACKRF_SUCCESS) {
mexPrintf("hackrf_board_id_read() failed: %s (%d)\n",hackrf_error_name((hackrf_error)result), result);
}
mexPrintf("Board ID Number: %d (%s)\n", board_id,hackrf_board_id_name((hackrf_board_id)board_id));
result = hackrf_version_string_read(_device[i], &version[0], 255);
if (result != HACKRF_SUCCESS) {
mexPrintf("hackrf_version_string_read() failed: %s (%d)\n",hackrf_error_name((hackrf_error)result), result);
}
printf("Firmware Version: %s\n", version);
result = hackrf_board_partid_serialno_read(_device[i], &read_partid_serialno);
if (result != HACKRF_SUCCESS) {
mexPrintf( "hackrf_board_partid_serialno_read() failed: %s (%d)\n",hackrf_error_name((hackrf_error)result), result);
}
printf("Part ID Number: 0x%08x 0x%08x\n",
read_partid_serialno.part_id[0],
read_partid_serialno.part_id[1]);
printf("Serial Number: 0x%08x 0x%08x 0x%08x 0x%08x\n",
read_partid_serialno.serial_no[0],
read_partid_serialno.serial_no[1],
read_partid_serialno.serial_no[2],
read_partid_serialno.serial_no[3]);
result = hackrf_close(_device[i]);
if (result != HACKRF_SUCCESS) {
mexPrintf("hackrf_close() failed: %s (%d)\n",hackrf_error_name((hackrf_error)result), result);
}
}
hackrf_device_list_free(list);
hackrf_exit();
}
