SDRplay API的使用示例

CC?=gcc
CFLAGS?=-O2 -g -Wall
LDLIBS+= -lpthread -lm -lsdrplay_api

all: play_sdr

%.o: %.c
    $(CC) $(CFLAGS) -c $<

play_sdr: play_sdr.o
    $(CC) -g -o play_sdr play_sdr.o $(LDFLAGS) $(LDLIBS)

run:
    ./play_sdr

clean:
    rm -f *.o play_sdr

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include "sdrplay_api.h"

sdrplay_api_DeviceT *chosenDevice = NULL;

void StreamACallback(short *xi, short *xq, sdrplay_api_StreamCbParamsT *params, unsigned int numSamples, unsigned int reset, void *cbContext)
{
    if (reset)
        printf("sdrplay_api_StreamACallback: numSamples=%d
", numSamples);

    // Process stream callback data here
    printf("New sample block: %d
", numSamples);
//    for (size_t i = 0; i < numSamples; ++i) {
//        printf("%d, %d
", *(xi++), *(xq++));
//    }

    return;
}

void EventCallback(sdrplay_api_EventT eventId, sdrplay_api_TunerSelectT tuner, sdrplay_api_EventParamsT *params, void *cbContext)
{
    switch(eventId)
    {
    case sdrplay_api_GainChange:
        printf("sdrplay_api_EventCb: %s, tuner=%s gRdB=%d lnaGRdB=%d systemGain=%.2f
", "sdrplay_api_GainChange", (tuner == sdrplay_api_Tuner_A)? "sdrplay_api_Tuner_A": "sdrplay_api_Tuner_B", params->gainParams.gRdB, params->gainParams.lnaGRdB, params->gainParams.currGain);
        break;

    case sdrplay_api_PowerOverloadChange:
        printf("sdrplay_api_PowerOverloadChange: tuner=%s powerOverloadChangeType=%s
", (tuner == sdrplay_api_Tuner_A)? "sdrplay_api_Tuner_A": "sdrplay_api_Tuner_B", (params->powerOverloadParams.powerOverloadChangeType == sdrplay_api_Overload_Detected)? "sdrplay_api_Overload_Detected": "sdrplay_api_Overload_Corrected");
        // Send update message to acknowledge power overload message received
        sdrplay_api_Update(chosenDevice->dev, tuner, sdrplay_api_Update_Ctrl_OverloadMsgAck, sdrplay_api_Update_Ext1_None);
        break;

    case sdrplay_api_DeviceRemoved:
        printf("sdrplay_api_EventCb: %s
", "sdrplay_api_DeviceRemoved");
        break;

    default:
        printf("sdrplay_api_EventCb: %d, unknown event
", eventId);
        break;
    }
}

void usage(void)
{
    printf("Usage: sdr_play.exe
");
    exit(1);
}

int main(int argc, char *argv[])
{
    sdrplay_api_DeviceT devs[6];
    unsigned int ndev; 
    int i;
    float ver = 0.0;
    sdrplay_api_ErrT err;
    sdrplay_api_DeviceParamsT *deviceParams = NULL;
    sdrplay_api_CallbackFnsT cbFns;
    sdrplay_api_RxChannelParamsT *chParams;

    char c;
    unsigned int chosenIdx = 0;

    // Open API
    if ((err = sdrplay_api_Open()) != sdrplay_api_Success)
    {
        printf("sdrplay_api_Open failed %s
", sdrplay_api_GetErrorString(err));
    }
    else
    {
        // Enable debug logging output
        if ((err = sdrplay_api_DebugEnable(NULL, 1)) != sdrplay_api_Success)
        {
            printf("sdrplay_api_DebugEnable failed %s
", sdrplay_api_GetErrorString(err));
        }

        // Check API versions match
        if ((err = sdrplay_api_ApiVersion(&ver)) != sdrplay_api_Success)
        {
            printf("sdrplay_api_ApiVersion failed %s
", sdrplay_api_GetErrorString(err));
        }
        if (ver != SDRPLAY_API_VERSION)
        {
            printf("API version don't match (local=%.2f dll=%.2f)
", SDRPLAY_API_VERSION, ver);
            goto CloseApi;
        }

        // Lock API while device selection is performed
        sdrplay_api_LockDeviceApi();

        // Fetch list of available devices
        if ((err = sdrplay_api_GetDevices(devs, &ndev, sizeof(devs) / sizeof(sdrplay_api_DeviceT))) != sdrplay_api_Success)
        {
            printf("sdrplay_api_GetDevices failed %s
", sdrplay_api_GetErrorString(err));
            goto UnlockDeviceAndCloseApi;
        }
        printf("MaxDevs=%ld NumDevs=%d
", sizeof(devs) / sizeof(sdrplay_api_DeviceT), ndev);
        if (ndev > 0)
        {
            for (i = 0; i < (int)ndev; i++)
            {
                printf("Dev%d: SerNo=%s hwVer=%d tuner=0x%.2x
", i, devs[i].SerNo, devs[i].hwVer, devs[i].tuner);
            }

            // Pick first device of any type
            for (i = 0; i < (int)ndev; i++)
            {
                chosenIdx = i;
                break;
            }
            if (i == ndev)
            {
                printf("Couldn't find a suitable device to open - exiting
");
                goto UnlockDeviceAndCloseApi;
            }
            printf("chosenDevice = %d
", chosenIdx);
            chosenDevice = &devs[chosenIdx];

            // Select chosen device
            if ((err = sdrplay_api_SelectDevice(chosenDevice)) != sdrplay_api_Success)
            {
                printf("sdrplay_api_SelectDevice failed %s
", sdrplay_api_GetErrorString(err));
                goto UnlockDeviceAndCloseApi;
            }

            // Unlock API now that device is selected
            sdrplay_api_UnlockDeviceApi();

            // Retrieve device parameters so they can be changed if wanted
            if ((err = sdrplay_api_GetDeviceParams(chosenDevice->dev, &deviceParams)) != sdrplay_api_Success)
            {
                printf("sdrplay_api_GetDeviceParams failed %s
", sdrplay_api_GetErrorString(err));
                goto CloseApi;
            }

            // Check for NULL pointers before changing settings
            if (deviceParams == NULL)
            {
                printf("sdrplay_api_GetDeviceParams returned NULL deviceParams pointer
");
                goto CloseApi;
            }

            // Configure dev parameters
            if (deviceParams->devParams != NULL) // This will be NULL for slave devices as only the master can change these parameters
            {
                // Only need to update non-default settings
                // Change from default Fs 2MHz - 10MHz
                deviceParams->devParams->fsFreq.fsHz = 2.0e6;
            }

            // Configure tuner parameters (depends on selected Tuner which set of parameters to use)
            chParams = (chosenDevice->tuner == sdrplay_api_Tuner_B)? deviceParams->rxChannelB: deviceParams->rxChannelA;
            if (chParams != NULL)
            {
                chParams->tunerParams.rfFreq.rfHz = 95.0e6;
                chParams->tunerParams.bwType = sdrplay_api_BW_1_536;
                chParams->tunerParams.ifType = sdrplay_api_IF_Zero;
                chParams->tunerParams.gain.gRdB = 35;
                chParams->tunerParams.gain.LNAstate = 1;

                // Disable AGC
                //chParams->ctrlParams.agc.enable = sdrplay_api_AGC_DISABLE;
                chParams->ctrlParams.agc.enable = sdrplay_api_AGC_100HZ;
            }
            else
            {
                printf("sdrplay_api_GetDeviceParams returned NULL chParams pointer
");
                goto CloseApi;
            }

            // Assign callback functions to be passed to sdrplay_api_Init()
            cbFns.StreamACbFn = StreamACallback;
            cbFns.EventCbFn = EventCallback;

            // Now we're ready to start by calling the initialisation function
            // This will configure the device and start streaming
            if ((err = sdrplay_api_Init(chosenDevice->dev, &cbFns, NULL)) != sdrplay_api_Success)
            {
                printf("sdrplay_api_Init failed %s
", sdrplay_api_GetErrorString(err));
                goto CloseApi;
            } else {
                printf("sdrplay_api_Init success!
");
            }

            while (1) // Small loop allowing user to control gain reduction in +/-1dB steps using keyboard keys
            {
                c = getchar();
                if (c == 'q')
                {
                    break;
                }
                else if (c == 'u')
                {
                    chParams->tunerParams.gain.gRdB += 1;
                    // Limit it to a maximum of 59dB
                    if (chParams->tunerParams.gain.gRdB > 59)
                        chParams->tunerParams.gain.gRdB = 20;
                    if ((err = sdrplay_api_Update(chosenDevice->dev, chosenDevice->tuner, sdrplay_api_Update_Tuner_Gr, sdrplay_api_Update_Ext1_None)) != sdrplay_api_Success)
                    {
                        printf("sdrplay_api_Update sdrplay_api_Update_Tuner_Gr failed %s
", sdrplay_api_GetErrorString(err));
                        break;
                    }
                }
                else if (c == 'd')
                {
                    chParams->tunerParams.gain.gRdB -= 1;
                    // Limit it to a minimum of 20dB
                    if (chParams->tunerParams.gain.gRdB < 20)
                        chParams->tunerParams.gain.gRdB = 59;
                    if ((err = sdrplay_api_Update(chosenDevice->dev, chosenDevice->tuner, sdrplay_api_Update_Tuner_Gr, sdrplay_api_Update_Ext1_None)) != sdrplay_api_Success)
                    {
                        printf("sdrplay_api_Update sdrplay_api_Update_Tuner_Gr failed %s
", sdrplay_api_GetErrorString(err));
                        break;
                    }
                }
            usleep(100000);
            }

            // Finished with device so uninitialise it
            if ((err = sdrplay_api_Uninit(chosenDevice->dev)) != sdrplay_api_Success)
            {
                printf("sdrplay_api_Uninit failed %s
", sdrplay_api_GetErrorString(err));
                goto CloseApi;
            }

            // Release device (make it available to other applications)
            sdrplay_api_ReleaseDevice(chosenDevice);
        }
UnlockDeviceAndCloseApi:
        // Unlock API
        sdrplay_api_UnlockDeviceApi();

CloseApi:
        // Close API
        sdrplay_api_Close();
    }

    return 0;
}