Как копировать данные из приема буфера в буфер передачи с использованием Libiio v 0,26? ⇐ Linux

[Anonymous]

Я попытался скопировать данные из буфера приема в буфер передачи, используя следующий код: < /p>
#include
#include
#include
#include
#include
#include
#define rx_b_s p_dat = iio_buffer_first(rxbuf, rx0_i)
#define tx_b_s p_dat2 = iio_buffer_first(txbuf, tx0_i)
#define rx_inc p_dat += p_inc
#define tx_inc p_dat2 += p_inc2
#define rx_con p_dat < p_end
#define tx_con p_dat2 < p_end2

#define BUFF_SIZE 1000000
#define KHZ(x) ((long long)(x * 100000.0 + .5))
#define MHZ(x) ((long long)(x * 1000000.0 + .5))
#define GHZ(x) ((long long)(x * 1000000000.0 + .5))

void receive(struct iio_context *ctx, struct iio_channel *RX_LO) {
struct timeval start_tv, end_tv;
long long start_us, end_us;
double elapsed_ms, elapsed_ms2, elapsed_ms3;

struct iio_device *dev;
struct iio_device *dev2;
struct iio_channel *rx0_i, *rx0_q;
struct iio_channel *tx0_i, *tx0_q;
struct iio_buffer *rxbuf;
struct iio_buffer *txbuf;

dev = iio_context_find_device(ctx, "cf-ad9361-lpc");
dev2 = iio_context_find_device(ctx, "cf-ad9361-dds-core-lpc");
rx0_i = iio_device_find_channel(dev, "voltage0", false);
rx0_q = iio_device_find_channel(dev, "voltage1", false);
tx0_i = iio_device_find_channel(dev2, "voltage2", true);
tx0_q = iio_device_find_channel(dev2, "voltage3", true);

if (iio_channel_is_scan_element(rx0_i)) {
iio_channel_enable(rx0_i);
printf("RX0_I enabled\n");
} else {
printf("RX0_I cannot be enabled\n");
}
if (iio_channel_is_scan_element(rx0_q)) {
iio_channel_enable(rx0_q);
printf("RX0_Q enabled\n");
} else {
printf("RX0_Q cannot be enabled\n");
}
if (iio_channel_is_scan_element(tx0_i)) {
iio_channel_enable(tx0_i);
printf("TX0_I enabled\n");
} else {
printf("TX0_I cannot be enabled\n");
}
if (iio_channel_is_scan_element(tx0_q)) {
iio_channel_enable(tx0_q);
printf("TX0_Q enabled\n");
} else {
printf("RX0_Q cannot be enabled\n");
}

rxbuf = iio_device_create_buffer(dev, BUFF_SIZE, false);
txbuf = iio_device_create_buffer(dev2, BUFF_SIZE, false);
if (!rxbuf) {
perror("Could not create RX buffer\n");
shutdown();
}
if (!txbuf) {
perror("Could not create TX buffer\n");
shutdown();
}

ssize_t num, num2;
while (true) {
void *p_dat1;
ptrdiff_t p_inc = iio_buffer_step(rxbuf);

void *p_dat2;
ptrdiff_t p_inc2 = iio_buffer_step(txbuf);

void *p_end = iio_buffer_end(rxbuf);
void *p_end2 = iio_buffer_end(txbuf);

void *p_start2 = iio_buffer_start(txbuf);
void *p_start = iio_buffer_start(rxbuf);

// first variant
//==========================================================================
// num=iio_buffer_refill(rxbuf);
// memcpy(p_start2,p_start,4*BUFF_SIZE);
// num2=iio_buffer_push(txbuf);
//==========================================================================

// second variant
num = iio_buffer_refill(rxbuf);

if (num > 0) {
printf("Refilled:%d\n", num);
}
for (p_dat1 = iio_buffer_first(rxbuf, rx0_i), p_dat2 = iio_buffer_start(txbuf); p_dat1 < p_end; p_dat1 += p_inc, p_dat2 += p_inc2) {
const int16_t i = ((int16_t *)p_dat1)[0];
const int16_t q = ((int16_t *)p_dat1)[1];
((int16_t *)p_dat2)[0] = i;
((int16_t *)p_dat2)[1] = q;
}
num2 = iio_buffer_push(txbuf);
if (num2 > 0) {
printf("Pushed:%d\n", num2);
}
}
iio_buffer_destroy(rxbuf);
iio_buffer_destroy(txbuf);
}

int main() {
struct iio_context *ctx;
struct iio_device *phy;
struct iio_channel *rec;
struct iio_channel *transmit;
struct iio_channel *RX_LO;
struct iio_channel *TX_LO;
ctx = iio_create_context_from_uri("ip:192.168.2.1");
phy = iio_context_find_device(ctx, "ad9361-phy");
rec = iio_device_find_channel(phy, "voltage0", false);
transmit = iio_device_find_channel(phy, "voltage0", true);
RX_LO = iio_device_find_channel(phy, "altvoltage0", true);
TX_LO = iio_device_find_channel(phy, "altvoltage1", true);
iio_channel_attr_write_longlong(RX_LO, "frequency", 120000000); /* RX LO frequency 2.4GHz */
iio_channel_attr_write_longlong(rec, "rf_bandwidth", 50000000);
iio_channel_attr_write_longlong(rec, "hardwaregain", 40);
iio_channel_attr_write_longlong(rec, "sampling_frequency", 50000000);
iio_channel_attr_write_longlong(TX_LO, "frequency", 1080000000); /*TX LO frequency 3GHz*/
iio_channel_attr_write_longlong(transmit, "rf_bandwidth", 50000000);
iio_channel_attr_write_longlong(transmit, "hardwaregain", 60);
iio_channel_attr_write_longlong(transmit, "sampling_frequency", 50000000);
receive(ctx, RX_LO);
iio_context_destroy(ctx);
return 0;
}
< /code>
К сожалению, этот код не позволяет копировать данные из регистрационного буфера в буфере передачи. Образцы в буфере ".
документация библиотеки.>

Подробнее здесь: https://stackoverflow.com/questions/797 ... iio-v-0-26