hamnet70/impl/src/main.c

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <liquid/liquid.h>

#include "utils.h"
#include "packet_mod.h"
#include "config.h"
#include "preamble.h"
#include "transmission.h"

int main(void)
{
	uint8_t msg_org[] = "Hello Liquid! This is the message to transmit. Hopefully it can be decoded correctly...";

	fec q = fec_create(CHANNEL_CODE, NULL);

	modem demod = modem_create(MODULATION);

	channel_cccf channel = channel_cccf_create();

	float snr = 50.0f;
	channel_cccf_add_awgn(channel, -snr, snr);
	channel_cccf_add_carrier_offset(channel, 0.10f, 1.00f);


	packet_mod_ctx_t pmod;
	packet_mod_init(&pmod);

	packet_mod_set_data(&pmod, msg_org, sizeof(msg_org));
	packet_mod_encode(&pmod);
	packet_mod_modulate(&pmod);
	packet_mod_add_header(&pmod);
	packet_mod_add_preamble(&pmod);

	size_t nsyms;
	packet_mod_get_result_cf(&pmod, NULL, &nsyms); // determine number of symbols for allocation

	float complex msg_mod[nsyms];
	packet_mod_get_result_cf(&pmod, msg_mod, &nsyms); // get the data

	size_t burst_len = 0;
	float complex whole_burst[65536];
	size_t len;

	transmission_ctx_t transm;
	transmission_init(&transm);

	len = 65536-burst_len;
	if(transmission_ramp_up(&transm, whole_burst+burst_len, &len) != OK) {
		printf("Ramp-up requires %zd symbols at offset %zd.\n", len, burst_len);
		return 1;
	}
	burst_len += len;

	len = 65536-burst_len;
	if(transmission_filter_packet(&transm, msg_mod, nsyms, whole_burst+burst_len, &len) != OK) {
		printf("Packet requires %zd symbols at offset %zd.\n", len, burst_len);
		return 1;
	}
	burst_len += len;

	len = 65536-burst_len;
	if(transmission_ramp_down(&transm, whole_burst+burst_len, &len) != OK) {
		printf("Ramp-down requires %zd symbols at offset %zd.\n", len, burst_len);
		return 1;
	}
	burst_len += len;

	dump_array_cf(whole_burst, burst_len, 1.0f, "/tmp/tx.cpx");

	// channel
	float complex msg_received[burst_len];

	//memcpy(msg_received, whole_burst, sizeof(whole_burst)); // no noise in channel

	channel_cccf_execute_block(channel, whole_burst, burst_len, msg_received);
	dump_array_cf(msg_received, burst_len, 1.0f, "/tmp/rx.cpx");

	// create NCO for carrier frequency compensation
	nco_crcf carrier_nco = nco_crcf_create(LIQUID_NCO);
	nco_crcf_set_frequency(carrier_nco, 0.00f);
	nco_crcf_set_phase(carrier_nco, 0.0f);

	// create symbol synchronizer
	symsync_crcf symsync = symsync_crcf_create_rnyquist(LIQUID_FIRFILT_RRC, RRC_SPS, RRC_DELAY, RRC_BETA, 32);

	float complex symsync_out[burst_len];
	unsigned int  symsync_out_len = 0;

#define FREQ_EST_L 16
	float phase_history[FREQ_EST_L];
	memset(phase_history, 0, sizeof(phase_history));

	for(unsigned int i = 0; i < burst_len; i++) {
		// Mix the input signal with the carrier NCO, which oscillates at the
		// frequency estimated so far.
		float complex mixed_sample;
		nco_crcf_step(carrier_nco);
		nco_crcf_mix_down(carrier_nco, msg_received[i], &mixed_sample);

		// run the timing synchronizer (works even with shifted frequency
		unsigned int out_len;
		symsync_crcf_execute(symsync, &mixed_sample, 1, symsync_out + symsync_out_len, &out_len);

		if(out_len != 0) {
			// for all the output samples produced, run the frequency
			// estimator. This is an implementation that works with unknown
			// BPSK symbols and therefore can be used during ramp-up and
			// preamble.

			if(out_len < FREQ_EST_L) {
				memmove(phase_history,
						phase_history + out_len,
						(FREQ_EST_L-out_len) * sizeof(phase_history[0]));
			}

			for(unsigned int j = 0; j < out_len; j++) {
				float complex *psymbol = symsync_out + symsync_out_len + j;

				// square the symbol to remove BPSK ambiguity
				float phase = cargf((*psymbol) * (*psymbol));

				phase_history[FREQ_EST_L - out_len + j] = phase;
			}

			// update the frequency estimate
			float unwrapped_phase_history[FREQ_EST_L];
			memcpy(unwrapped_phase_history, phase_history, sizeof(unwrapped_phase_history));
			liquid_unwrap_phase(unwrapped_phase_history, FREQ_EST_L);

			// calculate slope of LMS-fitted line
			float mean_index = (FREQ_EST_L-1) / 2.0f;
			float mean_phase = 0.0f;
			for(unsigned int j = 0; j < FREQ_EST_L; j++) {
				mean_phase += unwrapped_phase_history[j];
			}
			mean_phase /= FREQ_EST_L;

			float numerator = 0.0f;
			float denominator = 0.0f;
			for(unsigned int j = 0; j < FREQ_EST_L; j++) {
				float delta_index = j - mean_index;
				numerator += delta_index * (unwrapped_phase_history[j] - mean_phase);
				denominator += delta_index*delta_index;
			}

			float lms_phase_change = numerator / denominator;

			nco_crcf_adjust_frequency(carrier_nco, lms_phase_change / RRC_SPS / 32);

			printf("Phase change: %.6f - carrier frequency: %.6f\n", lms_phase_change, nco_crcf_get_frequency(carrier_nco));

			if(i/RRC_SPS == 2*FREQ_EST_L) {
				float complex tmp[FREQ_EST_L];
				for(unsigned int j = 0; j < FREQ_EST_L; j++) {
					tmp[j] = unwrapped_phase_history[j];
				}
				dump_array_cf(tmp, FREQ_EST_L, 1.0f, "/tmp/freq_est.cpx");
				printf("MARK\n");
			}
		}

		symsync_out_len += out_len;
	}

	dump_array_cf(symsync_out, symsync_out_len, 1.0f, "/tmp/rx.cpx");

#if 0
	// demodulate
	unsigned int bps = modem_get_bps(demod);

	unsigned char msg_demod_syms[nsyms];
	unsigned char msg_demod[k+1];

	for(size_t i = 0; i < nsyms; i++) {
		unsigned int symbol;

		modem_demodulate(demod, msg_received[i], &symbol);
		msg_demod_syms[i] = symbol;
	}

	unsigned int received_bytes;
	liquid_repack_bytes(msg_demod_syms, bps, nsyms, msg_demod, 8, sizeof(msg_demod), &received_bytes);

	//assert(received_bytes == k);

	// decode
	uint8_t msg_dec[sizeof(msg_org)];
	//memcpy(msg_dec, msg_enc, sizeof(msg_dec));
	fec_decode(q, sizeof(msg_dec), msg_demod, msg_dec);

	// compare original to decoded message
	for(size_t i = 0; i < sizeof(msg_org); i++)
	{
		printf("%02x  =>  %02x", msg_org[i], msg_dec[i]);
		if(msg_org[i] != msg_dec[i]) {
			printf("  <<< !!!\n");
		} else {
			printf("\n");
		}
	}

	unsigned int bit_errors = count_bit_errors_array(msg_org, msg_dec, sizeof(msg_org));
	printf("%u bit errors detected.\n", bit_errors);
#endif

	nco_crcf_destroy(carrier_nco);

	symsync_crcf_destroy(symsync);

	fec_destroy(q);

	modem_destroy(demod);

	channel_cccf_destroy(channel);

	printf("Done.\n");
}