hackrf_transfer: add fixed-point support for frequency and sample rate

Author: antoinevg

host/hackrf-tools/src/hackrf_transfer.c

@@ -194,6 +194,12 @@ typedef struct {
 
 t_u64toa ascii_u64_data[4];
 
+typedef struct {
+	char data[U64TOA_MAX_DIGIT + 1];
+} t_fp64toa;
+
+t_fp64toa ascii_fp64_data[4];
+
 static float TimevalDiff(const struct timeval* a, const struct timeval* b)
 {
 	return (a->tv_sec - b->tv_sec) + 1e-6f * (a->tv_usec - b->tv_usec);
@@ -255,23 +261,23 @@ int parse_u32(char* s, uint32_t* const value)
 	}
 }
 
-/* Parse frequencies as doubles to take advantage of notation parsing */
-int parse_frequency_i64(char* optarg, char* endptr, int64_t* value)
+int parse_frequency_u32(char* optarg, char* endptr, uint32_t* value)
 {
-	*value = (int64_t) strtod(optarg, &endptr);
+	*value = (uint32_t) strtod(optarg, &endptr);
 	if (optarg == endptr) {
 		return HACKRF_ERROR_INVALID_PARAM;
 	}
 	return HACKRF_SUCCESS;
 }
 
-int parse_frequency_u32(char* optarg, char* endptr, uint32_t* value)
+int parse_frequency_fp(char* optarg, char* endptr, fp_40_24_t* value)
 {
-	*value = (uint32_t) strtod(optarg, &endptr);
-	if (optarg == endptr) {
-		return HACKRF_ERROR_INVALID_PARAM;
-	}
-	return HACKRF_SUCCESS;
+	return hackrf_str_to_fp64(24, optarg, endptr, value);
+}
+
+int parse_sample_rate_fp(char* optarg, char* endptr, fp_28_36_t* value)
+{
+	return hackrf_str_to_fp64(36, optarg, endptr, value);
 }
 
 static char* stringrev(char* str)
@@ -319,6 +325,50 @@ char* u64toa(uint64_t val, t_u64toa* str)
 	return res;
 }
 
+char* fp64toa(uint8_t Qn, uint64_t value, t_fp64toa* str)
+{
+	uint64_t mask = (1ULL << Qn) - 1;
+	uint64_t m = value >> Qn;
+	uint64_t n = (Qn == 0) ? 0 : value & mask;
+	uint8_t precision = ceil((double) Qn * log10(2.0));
+
+	// format integer component
+	char* p = str->data;
+	p += sprintf(p, "%" PRIu64, m);
+
+	if (precision == 0 || n == 0) {
+		*p = '\0';
+		return str->data;
+	}
+	*p++ = '.';
+
+	// format fractional component
+	for (uint8_t i = 0; i < precision; i++) {
+		n *= 10;
+		char c = '0' + (n >> Qn);
+		*p++ = c;
+		n &= mask;
+	}
+
+	// trim trailing zeros
+	while (p > str->data && p[-1] == '0') {
+		--p;
+	}
+	*p = '\0';
+
+	return str->data;
+}
+
+char* frequency_fp64toa(uint64_t value, t_fp64toa* str)
+{
+	return fp64toa(24, value, str);
+}
+
+char* sample_rate_fp64toa(uint64_t value, t_fp64toa* str)
+{
+	return fp64toa(36, value, str);
+}
+
 static volatile bool do_exit = false;
 static volatile bool interrupted = false;
 static volatile bool tx_complete = false;
@@ -351,13 +401,16 @@ struct timeval time_start;
 struct timeval t_start;
 
 bool automatic_tuning = false;
-int64_t freq_hz;
+uint64_t freq_hz;
+fp_40_24_t freq_fp_hz;
 
 bool if_freq = false;
-int64_t if_freq_hz;
+uint64_t if_freq_hz;
+fp_40_24_t if_freq_fp_hz;
 
 bool lo_freq = false;
-int64_t lo_freq_hz = DEFAULT_LO_HZ;
+uint64_t lo_freq_hz = DEFAULT_LO_HZ;
+fp_40_24_t lo_freq_fp_hz = FREQ_FP_HZ(DEFAULT_LO_HZ);
 
 bool image_reject = false;
 uint32_t image_reject_selection;
@@ -369,7 +422,8 @@ bool antenna = false;
 uint32_t antenna_enable;
 
 bool sample_rate = false;
-uint32_t sample_rate_hz;
+fp_28_36_t sample_rate_fp_hz;
+uint64_t sample_rate_hz;
 
 bool force_ranges = false;
 
@@ -778,17 +832,20 @@ int main(int argc, char** argv)
 			break;
 
 		case 'f':
-			result = parse_frequency_i64(optarg, endptr, &freq_hz);
+			result = parse_frequency_fp(optarg, endptr, &freq_fp_hz);
+			freq_hz = FP_FREQ_HZ(freq_fp_hz);
 			automatic_tuning = true;
 			break;
 
 		case 'i':
-			result = parse_frequency_i64(optarg, endptr, &if_freq_hz);
+			result = parse_frequency_fp(optarg, endptr, &if_freq_fp_hz);
+			if_freq_hz = FP_FREQ_HZ(if_freq_fp_hz);
 			if_freq = true;
 			break;
 
 		case 'o':
-			result = parse_frequency_i64(optarg, endptr, &lo_freq_hz);
+			result = parse_frequency_fp(optarg, endptr, &lo_freq_fp_hz);
+			lo_freq_hz = FP_FREQ_HZ(lo_freq_fp_hz);
 			lo_freq = true;
 			break;
 
@@ -820,7 +877,8 @@ int main(int argc, char** argv)
 			break;
 
 		case 's':
-			result = parse_frequency_u32(optarg, endptr, &sample_rate_hz);
+			result = parse_sample_rate_fp(optarg, endptr, &sample_rate_fp_hz);
+			sample_rate_hz = FP_SR_HZ(sample_rate_fp_hz);
 			sample_rate = true;
 			break;
 
@@ -919,7 +977,8 @@ int main(int argc, char** argv)
 			usage();
 			return EXIT_FAILURE;
 		}
-		if (((if_freq_hz > IF_MAX_HZ) || (if_freq_hz < IF_MIN_HZ)) &&
+		if (((FP_FREQ_HZ(if_freq_fp_hz) > IF_MAX_HZ) ||
+		     (FP_FREQ_HZ(if_freq_fp_hz) < IF_MIN_HZ)) &&
 		    !force_ranges) {
 			fprintf(stderr,
 				"argument error: if_freq_hz should be between %s and %s.\n",
@@ -928,15 +987,17 @@ int main(int argc, char** argv)
 			usage();
 			return EXIT_FAILURE;
 		}
-		if ((if_freq_hz > IF_ABS_MAX_HZ) || (if_freq_hz < IF_ABS_MIN_HZ)) {
+		if ((FP_FREQ_HZ(if_freq_fp_hz) > IF_ABS_MAX_HZ) ||
+		    (FP_FREQ_HZ(if_freq_fp_hz) < IF_ABS_MIN_HZ)) {
 			fprintf(stderr,
 				"argument error: if_freq_hz must be between %s and %s.\n",
 				u64toa(IF_ABS_MIN_HZ, &ascii_u64_data[0]),
 				u64toa(IF_ABS_MAX_HZ, &ascii_u64_data[1]));
 			usage();
 			return EXIT_FAILURE;
 		}
-		if ((lo_freq_hz > LO_MAX_HZ) || (lo_freq_hz < LO_MIN_HZ)) {
+		if ((FP_FREQ_HZ(lo_freq_fp_hz) > LO_MAX_HZ) ||
+		    (FP_FREQ_HZ(lo_freq_fp_hz) < LO_MIN_HZ)) {
 			fprintf(stderr,
 				"argument error: lo_freq_hz shall be between %s and %s.\n",
 				u64toa(LO_MIN_HZ, &ascii_u64_data[0]),
@@ -958,23 +1019,31 @@ int main(int argc, char** argv)
 		switch (image_reject_selection) {
 		case RF_PATH_FILTER_BYPASS:
 			freq_hz = if_freq_hz;
+			freq_fp_hz = if_freq_fp_hz;
 			break;
 		case RF_PATH_FILTER_LOW_PASS:
 			freq_hz = (int64_t) labs((long int) (if_freq_hz - lo_freq_hz));
+			// TODO check
+			freq_fp_hz = (if_freq_fp_hz > lo_freq_fp_hz) ?
+				if_freq_fp_hz - lo_freq_fp_hz :
+				lo_freq_fp_hz - if_freq_fp_hz;
 			break;
 		case RF_PATH_FILTER_HIGH_PASS:
 			freq_hz = if_freq_hz + lo_freq_hz;
+			freq_fp_hz = if_freq_fp_hz + lo_freq_fp_hz;
 			break;
 		default:
 			freq_hz = DEFAULT_FREQ_HZ;
+			freq_fp_hz = FREQ_FP_HZ(DEFAULT_FREQ_HZ);
 			break;
 		}
 		fprintf(stderr,
 			"explicit tuning specified for %s Hz.\n",
-			u64toa(freq_hz, &ascii_u64_data[0]));
+			frequency_fp64toa(freq_fp_hz, &ascii_fp64_data[0]));
 
 	} else if (automatic_tuning) {
-		if (((freq_hz > FREQ_MAX_HZ) || (freq_hz < FREQ_MIN_HZ)) &&
+		if (((FP_FREQ_HZ(freq_fp_hz) > FREQ_MAX_HZ) ||
+		     (FP_FREQ_HZ(freq_fp_hz) < FREQ_MIN_HZ)) &&
 		    !force_ranges) {
 			fprintf(stderr,
 				"argument error: freq_hz should be between %s and %s.\n",
@@ -983,7 +1052,7 @@ int main(int argc, char** argv)
 			usage();
 			return EXIT_FAILURE;
 		}
-		if (freq_hz > FREQ_ABS_MAX_HZ) {
+		if (FP_FREQ_HZ(freq_fp_hz) > FREQ_ABS_MAX_HZ) {
 			fprintf(stderr,
 				"argument error: freq_hz must be between %s and %s.\n",
 				u64toa(FREQ_ABS_MIN_HZ, &ascii_u64_data[0]),
@@ -994,6 +1063,7 @@ int main(int argc, char** argv)
 	} else {
 		/* Use default freq */
 		freq_hz = DEFAULT_FREQ_HZ;
+		freq_fp_hz = FREQ_FP_HZ(DEFAULT_FREQ_HZ);
 		automatic_tuning = true;
 	}
 
@@ -1015,15 +1085,18 @@ int main(int argc, char** argv)
 	}
 
 	if (sample_rate) {
-		if (sample_rate_hz > SAMPLE_RATE_MAX_HZ && !force_ranges) {
+		fprintf(stderr,
+			"Setting sample rate to: %s Hz\n",
+			sample_rate_fp64toa(sample_rate_fp_hz, &ascii_fp64_data[0]));
+		if (FP_SR_HZ(sample_rate_fp_hz) > SAMPLE_RATE_MAX_HZ && !force_ranges) {
 			fprintf(stderr,
 				"argument error: sample_rate_hz should be less than or equal to %u Hz/%.03f MHz\n",
 				SAMPLE_RATE_MAX_HZ,
 				(float) (SAMPLE_RATE_MAX_HZ / FREQ_ONE_MHZ));
 			usage();
 			return EXIT_FAILURE;
 		}
-		if (sample_rate_hz < SAMPLE_RATE_MIN_HZ && !force_ranges) {
+		if (FP_SR_HZ(sample_rate_fp_hz) < SAMPLE_RATE_MIN_HZ && !force_ranges) {
 			fprintf(stderr,
 				"argument error: sample_rate_hz should be greater than or equal to %u Hz/%.03f MHz\n",
 				SAMPLE_RATE_MIN_HZ,
@@ -1033,6 +1106,7 @@ int main(int argc, char** argv)
 		}
 	} else {
 		sample_rate_hz = DEFAULT_SAMPLE_RATE_HZ;
+		sample_rate_fp_hz = SR_FP_HZ(DEFAULT_SAMPLE_RATE_HZ);
 	}
 
 	if (baseband_filter_bw) {
@@ -1100,7 +1174,7 @@ int main(int argc, char** argv)
 			PATH_FILE_MAX_LEN,
 			"HackRF_%sZ_%ukHz_IQ.wav",
 			date_time,
-			(uint32_t) (freq_hz / (1000ull)));
+			(uint32_t) (FP_FREQ_HZ(freq_fp_hz) / (1000ull)));
 		path = path_file;
 		fprintf(stderr, "Receive wav file: %s\n", path);
 	}
@@ -1116,6 +1190,7 @@ int main(int argc, char** argv)
 
 	// Change the freq and sample rate to correct the crystal clock error.
 	if (crystal_correct) {
+		// TODO this needs to be implemented for FP
 		sample_rate_hz =
 			(uint32_t) ((double) sample_rate_hz * (1000000 - crystal_correct_ppm) / 1000000 + 0.5);
 		freq_hz = freq_hz * (1000000 - crystal_correct_ppm) / 1000000;
@@ -1192,13 +1267,13 @@ int main(int argc, char** argv)
 #endif
 
 	fprintf(stderr,
-		"call hackrf_set_sample_rate(%u Hz/%.03f MHz)\n",
-		sample_rate_hz,
-		((float) sample_rate_hz / (float) FREQ_ONE_MHZ));
-	result = hackrf_set_sample_rate(device, sample_rate_hz);
+		"call hackrf_radio_set_sample_rate(%s Hz/%.03f MHz)\n",
+		sample_rate_fp64toa(sample_rate_fp_hz, &ascii_fp64_data[0]),
+		((float) FP_SR_HZ(sample_rate_fp_hz) / (float) FREQ_ONE_MHZ));
+	result = hackrf_radio_set_sample_rate(device, sample_rate_fp_hz);
 	if (result != HACKRF_SUCCESS) {
 		fprintf(stderr,
-			"hackrf_set_sample_rate() failed: %s (%d)\n",
+			"hackrf_radio_set_sample_rate() failed: %s (%d)\n",
 			hackrf_error_name(result),
 			result);
 		usage();
@@ -1246,13 +1321,13 @@ int main(int argc, char** argv)
 
 	if (automatic_tuning) {
 		fprintf(stderr,
-			"call hackrf_set_freq(%s Hz/%.03f MHz)\n",
-			u64toa(freq_hz, &ascii_u64_data[0]),
-			((double) freq_hz / (double) FREQ_ONE_MHZ));
-		result = hackrf_set_freq(device, freq_hz);
+			"call hackrf_radio_set_frequency(%s Hz/%.03f MHz)\n",
+			frequency_fp64toa(freq_fp_hz, &ascii_fp64_data[0]),
+			((float) FP_FREQ_HZ(freq_fp_hz) / (float) FREQ_ONE_MHZ));
+		result = hackrf_radio_set_frequency(device, freq_fp_hz);
 		if (result != HACKRF_SUCCESS) {
 			fprintf(stderr,
-				"hackrf_set_freq() failed: %s (%d)\n",
+				"hackrf_radio_set_frequency() failed: %s (%d)\n",
 				hackrf_error_name(result),
 				result);
 			usage();
@@ -1261,13 +1336,13 @@ int main(int argc, char** argv)
 	} else {
 		fprintf(stderr,
 			"call hackrf_set_freq_explicit() with %s Hz IF, %s Hz LO, %s\n",
-			u64toa(if_freq_hz, &ascii_u64_data[0]),
-			u64toa(lo_freq_hz, &ascii_u64_data[1]),
+			frequency_fp64toa(if_freq_fp_hz, &ascii_fp64_data[0]),
+			frequency_fp64toa(lo_freq_fp_hz, &ascii_fp64_data[0]),
 			hackrf_filter_path_name(image_reject_selection));
-		result = hackrf_set_freq_explicit(
+		result = hackrf_radio_set_frequency_explicit(
 			device,
-			if_freq_hz,
-			lo_freq_hz,
+			if_freq_fp_hz,
+			lo_freq_fp_hz,
 			image_reject_selection);
 		if (result != HACKRF_SUCCESS) {
 			fprintf(stderr,
@@ -1532,7 +1607,8 @@ int main(int argc, char** argv)
 			file_pos = ftell(file);
 			/* Update Wav Header */
 			wave_file_hdr.hdr.size = file_pos - 8;
-			wave_file_hdr.fmt_chunk.dwSamplesPerSec = sample_rate_hz;
+			wave_file_hdr.fmt_chunk.dwSamplesPerSec =
+				FP_SR_HZ(sample_rate_fp_hz);
 			wave_file_hdr.fmt_chunk.dwAvgBytesPerSec =
 				wave_file_hdr.fmt_chunk.dwSamplesPerSec * 2;
 			wave_file_hdr.data_chunk.chunkSize =