This discussion has been locked.
You can no longer post new replies to this discussion. If you have a question you can start a new discussion

Tansmit data part on adrv9009-iiostream.c based on zcu102_adrv9009(linux OS)

hello

if my question is not clear, i an sorry to bother you and please tell me.

i am in some trouble again.i use the default sd card image(default:BOOT.BIN Image system.dtb).the turn on the zcu102_adrv9009.

firstly,i use the iio-oscilloscope to test if the adrv9009 and zcu102 is working.i can see the boadrd is working because it can receive/transmit data by the gui and spectrum analyzer.

then i go to test the adrv9009-iiostream.c file you provide.

i creat a lte sigal(20MHz).you can see the picture.

i write some code the read data from this file, and send the data to transmit.here is my code.

/*
 * libiio - ADRV9009 IIO streaming example
 *
 * Copyright (C) 2014 IABG mbH
 * Author: Michael Feilen <feilen_at_iabg.de>
 * Copyright (C) 2019 Analog Devices Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 **/

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <signal.h>
#include <stdio.h>

#ifdef __APPLE__
#include <iio/iio.h>
#else
#include <iio.h>
#endif

/* helper macros */
#define MHZ(x) ((long long)(x*1000000.0 + .5))
#define GHZ(x) ((long long)(x*1000000000.0 + .5))

#define ASSERT(expr) { \
	if (!(expr)) { \
		(void) fprintf(stderr, "assertion failed (%s:%d)\n", __FILE__, __LINE__); \
		(void) abort(); \
	} \
}

/* RX is input, TX is output */
enum iodev { RX, TX };

/* common RX and TX streaming params */
struct stream_cfg {
	long long lo_hz; // Local oscillator frequency in Hz
};

/* static scratch mem for strings */
static char tmpstr[64];

/* IIO structs required for streaming */
static struct iio_context *ctx   = NULL;
static struct iio_channel *rx0_i = NULL;
static struct iio_channel *rx0_q = NULL;
static struct iio_channel *tx0_i = NULL;
static struct iio_channel *tx0_q = NULL;
static struct iio_buffer  *rxbuf = NULL;
static struct iio_buffer  *txbuf = NULL;

static bool stop;

/* cleanup and exit */
static void shutdown()
{
	printf("* Destroying buffers\n");
	if (rxbuf) { iio_buffer_destroy(rxbuf); }
	if (txbuf) { iio_buffer_destroy(txbuf); }

	printf("* Disabling streaming channels\n");
	if (rx0_i) { iio_channel_disable(rx0_i); }
	if (rx0_q) { iio_channel_disable(rx0_q); }
	if (tx0_i) { iio_channel_disable(tx0_i); }
	if (tx0_q) { iio_channel_disable(tx0_q); }

	printf("* Destroying context\n");
	if (ctx) { iio_context_destroy(ctx); }
	exit(0);
}

static void handle_sig(int sig)
{
	printf("Waiting for process to finish...\n");
	stop = true;
}

/* check return value of attr_write function */
static void errchk(int v, const char* what) {
	 if (v < 0) { fprintf(stderr, "Error %d writing to channel \"%s\"\nvalue may not be supported.\n", v, what); shutdown(); }
}

/* write attribute: long long int */
static void wr_ch_lli(struct iio_channel *chn, const char* what, long long val)
{
	errchk(iio_channel_attr_write_longlong(chn, what, val), what);
}

/* write attribute: long long int */
static long long rd_ch_lli(struct iio_channel *chn, const char* what)
{
	long long val;

	errchk(iio_channel_attr_read_longlong(chn, what, &val), what);

	printf("\t %s: %lld\n", what, val);
	return val;
}

#if 0
/* write attribute: string */
static void wr_ch_str(struct iio_channel *chn, const char* what, const char* str)
{
	errchk(iio_channel_attr_write(chn, what, str), what);
}
#endif

/* helper function generating channel names */
static char* get_ch_name_mod(const char* type, int id, char modify)
{
	snprintf(tmpstr, sizeof(tmpstr), "%s%d_%c", type, id, modify);
	return tmpstr;
}

/* helper function generating channel names */
static char* get_ch_name(const char* type, int id)
{
	snprintf(tmpstr, sizeof(tmpstr), "%s%d", type, id);
	return tmpstr;
}

/* returns adrv9009 phy device */
static struct iio_device* get_adrv9009_phy(struct iio_context *ctx)
{
	struct iio_device *dev =  iio_context_find_device(ctx, "adrv9009-phy");
	ASSERT(dev && "No adrv9009-phy found");
	return dev;
}

/* finds adrv9009 streaming IIO devices */
static bool get_adrv9009_stream_dev(struct iio_context *ctx, enum iodev d, struct iio_device **dev)
{
	switch (d) {
	case TX: *dev = iio_context_find_device(ctx, "axi-adrv9009-tx-hpc"); return *dev != NULL;
	case RX: *dev = iio_context_find_device(ctx, "axi-adrv9009-rx-hpc");  return *dev != NULL;
	default: ASSERT(0); return false;
	}
}

/* finds adrv9009 streaming IIO channels */
static bool get_adrv9009_stream_ch(struct iio_context *ctx, enum iodev d, struct iio_device *dev, int chid, char modify, struct iio_channel **chn)
{
	*chn = iio_device_find_channel(dev, modify ? get_ch_name_mod("voltage", chid, modify) : get_ch_name("voltage", chid), d == TX);
	if (!*chn)
		*chn = iio_device_find_channel(dev, modify ? get_ch_name_mod("voltage", chid, modify) : get_ch_name("voltage", chid), d == TX);
	return *chn != NULL;
}

/* finds adrv9009 phy IIO configuration channel with id chid */
static bool get_phy_chan(struct iio_context *ctx, enum iodev d, int chid, struct iio_channel **chn)
{
	switch (d) {
	case RX: *chn = iio_device_find_channel(get_adrv9009_phy(ctx), get_ch_name("voltage", chid), false); return *chn != NULL;
	case TX: *chn = iio_device_find_channel(get_adrv9009_phy(ctx), get_ch_name("voltage", chid), true);  return *chn != NULL;
	default: ASSERT(0); return false;
	}
}

/* finds adrv9009 local oscillator IIO configuration channels */
static bool get_lo_chan(struct iio_context *ctx, struct iio_channel **chn)
{
	 // LO chan is always output, i.e. true
	*chn = iio_device_find_channel(get_adrv9009_phy(ctx), get_ch_name("altvoltage", 0), true); return *chn != NULL;
}

/* applies streaming configuration through IIO */
bool cfg_adrv9009_streaming_ch(struct iio_context *ctx, struct stream_cfg *cfg, int chid)
{
	struct iio_channel *chn = NULL;

	// Configure phy and lo channels
	printf("* Acquiring ADRV9009 phy channel %d\n", chid);
	if (!get_phy_chan(ctx, true, chid, &chn)) {	return false; }

	rd_ch_lli(chn, "rf_bandwidth");
	rd_ch_lli(chn, "sampling_frequency");

	// Configure LO channel
	printf("* Acquiring ADRV9009 TRX lo channel\n");
	if (!get_lo_chan(ctx, &chn)) { return false; }
	wr_ch_lli(chn, "frequency", cfg->lo_hz);
	return true;
}

/* simple configuration and streaming */
int main (int argc, char **argv)
{
	// Streaming devices
	struct iio_device *tx;
	struct iio_device *rx;

	// RX and TX sample counters
	size_t nrx = 0;
	size_t ntx = 0;

	// Stream configuration
	struct stream_cfg trxcfg;
	FILE * fp;
	int16_t i1, i2;
	if ((fp = fopen("./LTE_20_1_92.16.txt", "r")) == NULL)
	{
		fprintf(stderr, "Can't open the file.");
		exit(EXIT_FAILURE);
	}
	// Listen to ctrl+c and ASSERT
	signal(SIGINT, handle_sig);

	// TRX stream config
	trxcfg.lo_hz = GHZ(2.5);

	printf("* Acquiring IIO context\n");
	ASSERT((ctx = iio_create_default_context()) && "No context");
	ASSERT(iio_context_get_devices_count(ctx) > 0 && "No devices");

	printf("* Acquiring ADRV9009 streaming devices\n");
	ASSERT(get_adrv9009_stream_dev(ctx, TX, &tx) && "No tx dev found");
	ASSERT(get_adrv9009_stream_dev(ctx, RX, &rx) && "No rx dev found");

	printf("* Configuring ADRV9009 for streaming\n");
	ASSERT(cfg_adrv9009_streaming_ch(ctx, &trxcfg, 0) && "TRX device not found");

	printf("* Initializing ADRV9009 IIO streaming channels\n");
	ASSERT(get_adrv9009_stream_ch(ctx, RX, rx, 0, 'i', &rx0_i) && "RX chan i not found");
	ASSERT(get_adrv9009_stream_ch(ctx, RX, rx, 0, 'q', &rx0_q) && "RX chan q not found");
	ASSERT(get_adrv9009_stream_ch(ctx, TX, tx, 0, 0, &tx0_i) && "TX chan i not found");
	ASSERT(get_adrv9009_stream_ch(ctx, TX, tx, 1, 0, &tx0_q) && "TX chan q not found");

	printf("* Enabling IIO streaming channels\n");
	iio_channel_enable(rx0_i);
	iio_channel_enable(rx0_q);
	iio_channel_enable(tx0_i);
	iio_channel_enable(tx0_q);

	printf("* Creating non-cyclic IIO buffers with 1 MiS\n");
	rxbuf = iio_device_create_buffer(rx, 1024*1024, false);
	if (!rxbuf) {
		perror("Could not create RX buffer");
		shutdown();
	}
	txbuf = iio_device_create_buffer(tx, 1024*1024, false);
	if (!txbuf) {
		perror("Could not create TX buffer");
		shutdown();
	}

	printf("* Starting IO streaming (press CTRL+C to cancel)\n");
	while (!stop)
	{
		ssize_t nbytes_rx, nbytes_tx;
		char *p_dat, *p_end;
		ptrdiff_t p_inc;

		// Schedule TX buffer
		nbytes_tx = iio_buffer_push(txbuf);
		if (nbytes_tx < 0) { printf("Error pushing buf %d\n", (int) nbytes_tx); shutdown(); }

		// Refill RX buffer
		nbytes_rx = iio_buffer_refill(rxbuf);
		if (nbytes_rx < 0) { printf("Error refilling buf %d\n",(int) nbytes_rx); shutdown(); }

		// READ: Get pointers to RX buf and read IQ from RX buf port 0
		p_inc = iio_buffer_step(rxbuf);
		p_end = iio_buffer_end(rxbuf);
		for (p_dat = iio_buffer_first(rxbuf, rx0_i); p_dat < p_end; p_dat += p_inc) {
			// Example: swap I and Q
			const int16_t i = ((int16_t*)p_dat)[0]; // Real (I)
			const int16_t q = ((int16_t*)p_dat)[1]; // Imag (Q)
			((int16_t*)p_dat)[0] = q;
			((int16_t*)p_dat)[1] = i;
		}

		// WRITE: Get pointers to TX buf and write IQ to TX buf port 0
		p_inc = iio_buffer_step(txbuf);
		p_end = iio_buffer_end(txbuf);
		for (p_dat = iio_buffer_first(txbuf, tx0_i); p_dat < p_end; p_dat += p_inc) {
			// Example: fill with zeros
			// 14-bit sample needs to be MSB alligned so shift by 2
			// https://wiki.analog.com/resources/eval/user-guides/ad-fmcomms2-ebz/software/basic_iq_datafiles#binary_format
			if (fscanf(fp, "%hd %hd", &i1, &i2) == EOF)
			{
				rewind(fp);
				fscanf(fp, "%hd %hd", &i1, &i2);
			}
			((int16_t*)p_dat)[0] = i1 << 2; // Real (I)
			((int16_t*)p_dat)[1] = i2 << 2; // Imag (Q)
		}

		// Sample counter increment and status output
		nrx += nbytes_rx / iio_device_get_sample_size(rx);
		ntx += nbytes_tx / iio_device_get_sample_size(tx);
		printf("\tRX %8.2f MSmp, TX %8.2f MSmp\n", nrx/1e6, ntx/1e6);
	}
	fclose(fp);
	shutdown();

	return 0;
}

you can see this picture too.

then i run this code.

you can see there is some error.

adrv9009 spi1.1: ERROR: 43: TALISE_gpIntHandler(): PA Protection Channel1 Reports Error

furthermore,in the spectrum analyzer there is something. 

TX1:no siganl

TX2:2.04GHz

i think that my signal is not sent successfully。

could you tell how to send siganl rightly.

do i need to do some configuration ?then i could send data by using this adrv9009-iiostream.c?

or something else?

if my question is not clear, i an sorry to bother you and please tell me.

here is similar question .

yes,i rebuild the hdl and generate the boot.bin,it works.but this example adrv9009-iiostream.c can not transmit data.in my spectrum analyzer is always a single  tone signal(40MHz) modulated by LO.

when the LO is 2GHz,TX is 2.04GHz.

when the LO is 2.5GHz,TX is 2.54GHz.

next picture is send code.we can the i/q is set 0,but the TX is still 2.04GHz.

another problem is that we have tried to read data from my own file(generate by matlab),.the details you can see next peicture.of course the data file format is same as yours.

the function of the code is read the data from the file ,and send it to the TX buffer.

but it seems that my TX code is not working.on my spectrum analyzer is still 2.04GHz.

if my question is not clear, i an sorry to bother you and please tell me.

thank you very much.




[locked by: aardelean at 2:43 PM (GMT 0) on 26 Feb 2020]
Parents
  • 0
    •  Analog Employees 
    on Jul 16, 2019 6:11 PM over 1 year ago

    I would recommend verifying your waveform by sending it with IIO-Scope first.

    If you are getting those PA errors you may have put the part in a bad state when configuring in IIO-Scope then in your C file. Restart the board before moving forward.

    -Travis

  • I use the waveform from Iio-scope t,then transmit data by adrv9009-iiostream.c.

    in the demo adrv9009-iiostream.c, I notice that you let transmit data filled by zero,butthere is still only the 2.04GHz in spectrum analyzer. And no matter how I change this data,in spectrum analyzer is still 2.04GHz.did you test this code on your board including receive/transmit data?

    it seems that this transmit data part have some bug?

    could you tell me how to transmit data by using this code?

    i want to transmit data by adrv9009-iiostream.c.

    please please help me.

    could you give me a demo that can transmit useful data by using adrv9009-iiostream.c.maybe we can see something in spectrum analyzer.

    thank you for your time 

    have a nice day

  • 0
    •  Analog Employees 
    on Jul 17, 2019 3:50 AM over 1 year ago in reply to zhongkai

    As I said your spectrum analyzer in the right photo is at the wrong frequency, which will not observe anything. Please check what is being transmitted out of the first port at 2.5 GHz, it should be a suppressed LO. When the script is not running the DDSs should be re-enabled.

    -Travis

  • Okay, I understand that the tx1 has no signal because it is set to zero.

    tx is not be modified so it is still 2.54GHZ

    so there is a question.

    how could I can transmit valid data by this code?

    could you provide some examples which could send data? How should I transmit my data   ?

    Thanks for your precious time.

    have a nice day.

    looking forward your reply.

  • hello.travis,i set the specturm in the right frequency.when i run the example which i/q=0,i can see it is a suppressed LO.

    then i copy the data file from the iio-scope.you can see details in next pictures.

      

    i use the data in next picture.and rename as Tx_20MHz_245.76Msps.txt.

    then copy it to zcu102 linux.

    here is my main.c code

    /* simple configuration and streaming */
    int main (int argc, char **argv)
    {
            // Streaming devices
            struct iio_device *tx;
            struct iio_device *rx;
    
            // RX and TX sample counters
            size_t nrx = 0;
            size_t ntx = 0;
    
            // Stream configuration
            struct stream_cfg trxcfg;
            FILE * fp, * fp1;
            int16_t i1, i2;
            if ((fp = fopen("./Tx_20MHz_245.76Msps.txt", "r")) == NULL)
            {
                    fprintf(stderr, "Can't open the file to read.");
                    exit(EXIT_FAILURE);
            }
            /*
            if ((fp1 = fopen("./LTE_20_1_92.16_to_write.txt", "w")) == NULL)
            {
                    fprintf(stderr, "Can't open the file to write.");
                    exit(EXIT_FAILURE);
            }
            */
            // Listen to ctrl+c and ASSERT
            signal(SIGINT, handle_sig);
    
            // TRX stream config
            trxcfg.lo_hz = GHZ(2.5);
    
            printf("* Acquiring IIO context\n");
            ASSERT((ctx = iio_create_default_context()) && "No context");
            ASSERT(iio_context_get_devices_count(ctx) > 0 && "No devices");
    
            printf("* Acquiring ADRV9009 streaming devices\n");
            ASSERT(get_adrv9009_stream_dev(ctx, TX, &tx) && "No tx dev found");
            ASSERT(get_adrv9009_stream_dev(ctx, RX, &rx) && "No rx dev found");
    
            printf("* Configuring ADRV9009 for streaming\n");
            ASSERT(cfg_adrv9009_streaming_ch(ctx, &trxcfg, 0) && "TRX device not found");
    
            printf("* Initializing ADRV9009 IIO streaming channels\n");
            ASSERT(get_adrv9009_stream_ch(ctx, RX, rx, 0, 'i', &rx0_i) && "RX chan i not found");
            ASSERT(get_adrv9009_stream_ch(ctx, RX, rx, 0, 'q', &rx0_q) && "RX chan q not found");
            ASSERT(get_adrv9009_stream_ch(ctx, TX, tx, 0, 0, &tx0_i) && "TX chan i not found");
            ASSERT(get_adrv9009_stream_ch(ctx, TX, tx, 1, 0, &tx0_q) && "TX chan q not found");
    
            printf("* Enabling IIO streaming channels\n");
            iio_channel_enable(rx0_i);
            iio_channel_enable(rx0_q);
            iio_channel_enable(tx0_i);
            iio_channel_enable(tx0_q);
    
            printf("* Creating non-cyclic IIO buffers with 1 MiS\n");
            rxbuf = iio_device_create_buffer(rx, 1024*1024, false);
            if (!rxbuf) {
                    perror("Could not create RX buffer");
                    shutdown();
            }
            txbuf = iio_device_create_buffer(tx, 1024*1024, false);
            if (!txbuf) {
                    perror("Could not create TX buffer");
                    shutdown();
            }
    
            printf("* Starting IO streaming (press CTRL+C to cancel)\n");
            while (!stop)
            {
                    ssize_t nbytes_rx, nbytes_tx;
                    char *p_dat, *p_end;
                    ptrdiff_t p_inc;
    
                    // Schedule TX buffer
                    nbytes_tx = iio_buffer_push(txbuf);
                    if (nbytes_tx < 0) { printf("Error pushing buf %d\n", (int) nbytes_tx); shutdown(); }
    
                    // Refill RX buffer
                    nbytes_rx = iio_buffer_refill(rxbuf);
                    if (nbytes_rx < 0) { printf("Error refilling buf %d\n",(int) nbytes_rx); shutdown(); }
    
                    // READ: Get pointers to RX buf and read IQ from RX buf port 0
                    p_inc = iio_buffer_step(rxbuf);
                    p_end = iio_buffer_end(rxbuf);
                    for (p_dat = iio_buffer_first(rxbuf, rx0_i); p_dat < p_end; p_dat += p_inc) {
                            // Example: swap I and Q
                            const int16_t i = ((int16_t*)p_dat)[0]; // Real (I)
                            const int16_t q = ((int16_t*)p_dat)[1]; // Imag (Q)
                    //      fprintf(fp1, "%hd %hd\r\n", i, q);
                            ((int16_t*)p_dat)[0] = q;
                            ((int16_t*)p_dat)[1] = i;
                    }
    
                    // WRITE: Get pointers to TX buf and write IQ to TX buf port 0
                    p_inc = iio_buffer_step(txbuf);
                    p_end = iio_buffer_end(txbuf);
                    for (p_dat = iio_buffer_first(txbuf, tx0_i); p_dat < p_end; p_dat += p_inc) {
                            // Example: fill with zeros    
                            // 14-bit sample needs to be MSB alligned so shift by 2
                            // https://wiki.analog.com/resources/eval/user-guides/ad-fmcomms2-ebz/software/basic_iq_datafiles#binary_format
                            if (fscanf(fp, "%hd %hd", &i1, &i2) == EOF)
                            {
                                    rewind(fp);
                                    fscanf(fp, "%hd %hd", &i1, &i2);
                            }
                            ((int16_t*)p_dat)[0] = i1 << 2; // Real (I)
                            ((int16_t*)p_dat)[1] = i2 << 2; // Imag (Q)
                    }
    
                    // Sample counter increment and status output
                    nrx += nbytes_rx / iio_device_get_sample_size(rx);
                    ntx += nbytes_tx / iio_device_get_sample_size(tx);
                    printf("\tRX %8.2f MSmp, TX %8.2f MSmp\n", nrx/1e6, ntx/1e6);
            }
            if (fclose(fp) != 0)
                    printf("Can't close the file to read.\n");
    //      if (fclose(fp1) != 0)
    //              printf("Can't close the file to write.\n");
            shutdown();
    
            return 0;
    }
    

    the key code is in next picture. read the file and write data to buffer.

    but i still can not see anything in my pectrum analyzer.of course i set frequency is 2.5GHz

    TX1:

    TX2:

    so my question is that ,the way that i read file and write i/q data to TX buf is not right?

    how can i write data to TX buf and transmit signal?

    would  you please teach me to do this?

    if what i said is not clearly,please tell me,i will re-write.

    thank you  for your precious time.

    have a nice day.

    looking forward your reply

  • 0
    •  Analog Employees 
    on Jul 17, 2019 4:12 PM over 1 year ago in reply to zhongkai

    Here is an offset LTE waveform and the script I use to transmit it.

    https://gist.github.com/c3bde97b6d6f32a40e0b1cfc4dae6ec3

    myFile.txt

    Here is what I observe out of TX1:

    -Travis

Reply Children