// 1. Initialize device
SoapySDR::Kwargs args;
args["driver"] = "mipi";
auto device = SoapySDR::Device::make(args);

// 2. Set an arbitrary sample rate (e.g., 60 MHz)
double requestedRate = 60e6;
device->setSampleRate(SOAPY_SDR_RX, 0, requestedRate);

// 3. Verify the actual rate applied
double actualRate = device->getSampleRate(SOAPY_SDR_RX, 0);
std::cout << "Streaming at: " << (actualRate / 1e6) << " MHz\n";

import SoapySDR
from SoapySDR import *

# 1. Initialize device
args = dict(driver="mipi")
device = SoapySDR.Device(args)

# 2. Set an arbitrary sample rate (e.g., 60 MHz)
requestedRate = 60e6
device.setSampleRate(SOAPY_SDR_RX, 0, requestedRate)

# 3. Verify the actual rate applied
actualRate = device.getSampleRate(SOAPY_SDR_RX, 0)
print(f"Streaming at: {actualRate / 1e6} MHz")

// Compile directly on the Pi5 terminal with command: 
// g++ -std=c++17 rx_test.cpp -o rx_test -lSoapySDR
#include <SoapySDR/Device.hpp>
#include <SoapySDR/Formats.hpp>
#include <csignal>
#include <atomic>
#include <vector>

std::atomic<bool> running(true);
void sigIntHandler(int) { running = false; }

int main() {
    std::signal(SIGINT, sigIntHandler);
    
    auto device = SoapySDR::Device::make({"driver": "mipi"});
    device->setSampleRate(SOAPY_SDR_RX, 0, 40e6);
    
    auto stream = device->setupStream(SOAPY_SDR_RX, SOAPY_SDR_CS8, {0});
    device->activateStream(stream);

    const size_t mtu = device->getStreamMTU(stream);
    std::vector<int8_t> buffer(mtu * 2); // * 2 for I and Q interleaved
    void *buffs[] = {buffer.data()};

    while (running) {
        int flags = 0;
        long long timeNs = 0;
        
        // Read up to 'mtu' samples
        int ret = device->readStream(stream, buffs, mtu, flags, timeNs, 100000); // 100ms timeout

        if (ret > 0) {
            // Process samples here. 
            // I = buffer[0], Q = buffer[1], etc.
        }
    }

    // Clean shutdown
    device->deactivateStream(stream);
    device->closeStream(stream);
    SoapySDR::Device::unmake(device);
    return 0;
}

import SoapySDR
from SoapySDR import *
import numpy as np
import signal

running = True
def sig_handler(signum, frame):
    global running
    running = False

signal.signal(signal.SIGINT, sig_handler)

device = SoapySDR.Device(dict(driver="mipi"))
device.setSampleRate(SOAPY_SDR_RX, 0, 40e6)

stream = device.setupStream(SOAPY_SDR_RX, SOAPY_SDR_CS8, [0])
device.activateStream(stream)

mtu = device.getStreamMTU(stream)
# Numpy array for interleaved CS8 I/Q data
buffer = np.zeros(mtu * 2, np.int8)

while running:
    # readStream takes a list of buffers (one per channel)
    sr = device.readStream(stream, [buffer], mtu, timeoutUs=100000)
    
    if sr.ret > 0:
        # Process samples here. buffer[0::2] are I, buffer[1::2] are Q
        pass

# Clean shutdown
device.deactivateStream(stream)
device.closeStream(stream)

// Compile directly on the Pi5 terminal with command: 
// g++ -std=c++17 tx_test.cpp -o tx_test -lSoapySDR
#include <SoapySDR/Device.hpp>
#include <SoapySDR/Formats.hpp>
#include <csignal>
#include <atomic>
#include <vector>
#include <cmath>

std::atomic<bool> running(true);
void sigIntHandler(int) { running = false; }

int main() {
    std::signal(SIGINT, sigIntHandler);
    
    auto device = SoapySDR::Device::make({"driver": "mipi"});
    
    double sampleRate = 40e6;
    device->setSampleRate(SOAPY_SDR_TX, 0, sampleRate);
    
    auto stream = device->setupStream(SOAPY_SDR_TX, SOAPY_SDR_CS8);
    device->activateStream(stream);

    const size_t mtu = device->getStreamMTU(stream);
    std::vector<int8_t> buffer(mtu * 2);
    const void *buffs[] = {buffer.data()};

    // Tone generation parameters
    double toneFreq = 1e6; // 1 MHz Tone
    double phase = 0.0;
    double phaseInc = 2.0 * M_PI * toneFreq / sampleRate;
    double amplitude = 100.0;

    while (running) {
        // Fill buffer with continuous wave (CW) tone
        for (size_t i = 0; i < mtu; i++) {
            buffer[i*2]     = static_cast<int8_t>(amplitude * std::cos(phase)); // I
            buffer[i*2 + 1] = static_cast<int8_t>(amplitude * std::sin(phase)); // Q
            
            // Advance phase and wrap around 2*PI
            phase += phaseInc;
            if (phase > 2.0 * M_PI) phase -= 2.0 * M_PI;
        }

        int flags = 0;
        int ret = device->writeStream(stream, buffs, mtu, flags, 0, 100000);
        
        if (ret < 0) break; // Error or Timeout
    }

    device->deactivateStream(stream);
    device->closeStream(stream);
    SoapySDR::Device::unmake(device);
    return 0;
}

import SoapySDR
from SoapySDR import *
import numpy as np
import signal

running = True
def sig_handler(signum, frame):
    global running
    running = False

signal.signal(signal.SIGINT, sig_handler)

device = SoapySDR.Device(dict(driver="mipi"))

sampleRate = 40e6
device.setSampleRate(SOAPY_SDR_TX, 0, sampleRate)

stream = device.setupStream(SOAPY_SDR_TX, SOAPY_SDR_CS8)
device.activateStream(stream)

mtu = device.getStreamMTU(stream)
buffer = np.zeros(mtu * 2, np.int8)

# Tone generation parameters
toneFreq = 1e6
phase = 0.0
phaseInc = 2.0 * np.pi * toneFreq / sampleRate
amplitude = 100.0

while running:
    # Use Numpy vectorization for fast CW tone generation
    phases = phase + np.arange(mtu) * phaseInc
    
    # Assign I (evens) and Q (odds)
    buffer[0::2] = (amplitude * np.cos(phases)).astype(np.int8)
    buffer[1::2] = (amplitude * np.sin(phases)).astype(np.int8)
    
    # Advance state phase
    phase = (phase + mtu * phaseInc) % (2.0 * np.pi)

    # Write exactly 'mtu' samples to the hardware
    sr = device.writeStream(stream, [buffer], mtu, timeoutUs=100000)
    
    if sr.ret < 0:
        break # Error or Timeout

device.deactivateStream(stream)
device.closeStream(stream)

// For 4-channel interleave mode, do not call setSampleRate(). Let it default to the native bypass rate.
auto stream = device->setupStream(SOAPY_SDR_RX, SOAPY_SDR_CS8, {0});
device->activateStream(stream);

// Calculate your actual per-channel rate
double aggregateRate = device->getSampleRate(SOAPY_SDR_RX, 0);
std::cout << "Per-Antenna Rate: " << (aggregateRate / 4.0 / 1e6) << " MHz\n";

// Inside your while(running) read loop:
int ret = device->readStream(stream, buffs, mtu, flags, timeNs, 100000);

if (ret > 0) {
    // 'ret' is the total number of complex elements returned across ALL antennas.
    // Loop through the raw buffer bytes in steps of 8 (4 antennas * 2 bytes each)
    size_t totalBytes = ret * 2;
    for (size_t i = 0; i < totalBytes; i += 8) {
        int8_t ant0_i = buffer[i + 0]; int8_t ant0_q = buffer[i + 1];
        int8_t ant1_i = buffer[i + 2]; int8_t ant1_q = buffer[i + 3];
        int8_t ant2_i = buffer[i + 4]; int8_t ant2_q = buffer[i + 5];
        int8_t ant3_i = buffer[i + 6]; int8_t ant3_q = buffer[i + 7];
        
        // Feed to DSP...
    }
}

# For 4-channel interleave mode, do not call setSampleRate(). Let it default to the native bypass rate.
stream = device.setupStream(SOAPY_SDR_RX, SOAPY_SDR_CS8, [0])
device.activateStream(stream)

# Calculate your actual per-channel rate
aggregateRate = device.getSampleRate(SOAPY_SDR_RX, 0)
print(f"Per-Antenna Rate: {(aggregateRate / 4.0) / 1e6} MHz")

# Inside your while running loop:
sr = device.readStream(stream, [buffer], mtu, timeoutUs=100000)

if sr.ret > 0:
    # Slice only the valid data received in this chunk
    valid_data = buffer[:sr.ret * 2]
    
    # Use Numpy's advanced slicing to instantly de-interleave the 4 antennas
    ant0_i = valid_data[0::8]
    ant0_q = valid_data[1::8]
    
    ant1_i = valid_data[2::8]
    ant1_q = valid_data[3::8]
    
    ant2_i = valid_data[4::8]
    ant2_q = valid_data[5::8]
    
    ant3_i = valid_data[6::8]
    ant3_q = valid_data[7::8]
    
    # Example: Combine into complex arrays
    # ant0 = ant0_i.astype(np.complex64) + 1j * ant0_q.astype(np.complex64)

// Initialize a remote device over the network
SoapySDR::Kwargs args;
args["driver"] = "remote";
args["remote"] = "quadrf.local";  // or replace with IP address
args["remote:driver"] = "mipi";

auto device = SoapySDR::Device::make(args);

// The rest of your code (setSampleRate, setupStream, etc.) remains exactly the same!

import SoapySDR

# Initialize a remote device over the network
args = dict(
    driver="remote", 
    remote="quadrf.local" # or replace with IP address
)
args["remote:driver"] = "mipi"

device = SoapySDR.Device(args)

# The rest of your code (setSampleRate, setupStream, etc.) remains exactly the same!