scrape
/
quisk-kc4upr
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
quisk-kc4upr/soapypkg/soapy.c

518 lines
16 KiB
C
Executable File
Raw Permalink Blame History

#include <Python.h>
#include <complex.h>
#include <SoapySDR/Device.h>
#include <SoapySDR/Formats.h>
#define IMPORT_QUISK_API
#include "quisk.h"
#include "filter.h"
// This module was written by James Ahlstrom, N2ADR.
// This module uses the Python interface to import symbols from the parent _quisk
// extension module. It must be linked with import_quisk_api.c. See the documentation
// at the start of import_quisk_api.c.
#define DEBUG 0
#define RX_BUF_SIZE (SAMP_BUFFER_SIZE / 2)
static SoapySDRDevice * soapy_sample_device; // device for the sample stream
static SoapySDRDevice * soapy_config_device; // device for configuration, not samples
static SoapySDRStream * rxStream;
static SoapySDRStream * txStream;
static double rx_sample_rate = 48000;
static double tx_sample_rate = 48000;
static complex float rx_stream_buffer[RX_BUF_SIZE];
static void * rx_stream_buffs[] = {rx_stream_buffer};
static int shutdown_sample_device;
static int data_poll_usec = 10000;
static int soapy_FDX; // Full duplex flag
static int soapy_KeyDown; // Current key state
static int soapy_KeyWasDown; // Previous key state
static size_t numTxChannels; // number of Tx channels
static size_t txMTU; // maximum transmission unit of Tx stream
// Start sample capture; called from the sound thread.
static void quisk_start_samples(void)
{
//setup an Rx and Tx stream (complex floats)
if (SoapySDRDevice_setupStream(soapy_sample_device, &rxStream, SOAPY_SDR_RX, SOAPY_SDR_CF32, NULL, 0, NULL) != 0) {
printf("Soapy Rx setupStream fail: %s\n", SoapySDRDevice_lastError());
return;
}
if (numTxChannels) {
if (SoapySDRDevice_setupStream(soapy_sample_device, &txStream, SOAPY_SDR_TX, SOAPY_SDR_CF32, NULL, 0, NULL) != 0) {
printf("Soapy Tx setupStream fail: %s\n", SoapySDRDevice_lastError());
return;
}
txMTU = SoapySDRDevice_getStreamMTU(soapy_sample_device, txStream);
}
SoapySDRDevice_activateStream(soapy_sample_device, rxStream, 0, 0, 0); //start streaming
}
// Stop sample capture; called from the sound thread.
static void quisk_stop_samples(void)
{
shutdown_sample_device = 1;
if (rxStream) {
SoapySDRDevice_deactivateStream(soapy_sample_device, rxStream, 0, 0); //stop streaming
SoapySDRDevice_closeStream(soapy_sample_device, rxStream);
rxStream = NULL;
}
if (txStream) {
SoapySDRDevice_deactivateStream(soapy_sample_device, txStream, 0, 0); //stop streaming
SoapySDRDevice_closeStream(soapy_sample_device, txStream);
txStream = NULL;
}
}
// Called in a loop to read samples; called from the sound thread.
static int quisk_read_samples(complex double * cSamples)
{
int i, flags; //flags set by receive operation
long long timeNs; //timestamp for receive buffer
int nSamples;
int num_samp;
soapy_KeyDown = quisk_is_key_down();
num_samp = (int)(rx_sample_rate * (data_poll_usec * 1E-6));
num_samp = ((num_samp + 255) / 256) * 256;
if (num_samp > RX_BUF_SIZE)
num_samp = RX_BUF_SIZE;
if (shutdown_sample_device) {
if (rxStream) {
quisk_stop_samples();
}
if (soapy_sample_device) {
SoapySDRDevice_unmake(soapy_sample_device);
soapy_sample_device = NULL;
}
nSamples = num_samp;
for (i = 0; i < nSamples; i++)
cSamples[i] = 0;
}
else if (rxStream) {
nSamples = SoapySDRDevice_readStream(soapy_sample_device, rxStream, rx_stream_buffs, num_samp, &flags, &timeNs, data_poll_usec * 2);
if (nSamples == -1) { // Timeout
nSamples = 0;
}
else if (nSamples < 0) { // Some other error
pt_quisk_sound_state->read_error++;
nSamples = 0;
}
pt_quisk_sound_state->latencyCapt = 0;
for (i = 0; i < nSamples; i++)
cSamples[i] = rx_stream_buffer[i] * CLIP32;
}
else {
nSamples = num_samp;
for (i = 0; i < nSamples; i++)
cSamples[i] = 0;
}
return nSamples; // return number of samples
}
// Called in a loop to write samples; called from the sound thread.
static int quisk_write_samples(complex double * cSamples, int nSamples)
{
static complex float * tx_stream_buffer = NULL;
static int tx_buf_size = 0;
static long long timeNs = 0;
int i, flags, ret, count;
if ( ! txStream)
return 0;
if (soapy_KeyDown != soapy_KeyWasDown) { // key changed state
soapy_KeyWasDown = soapy_KeyDown;
if (DEBUG)
printf("**** Key Change %i rate %.0f\n", soapy_KeyDown, tx_sample_rate);
if (soapy_KeyDown) // Key went down
SoapySDRDevice_activateStream(soapy_sample_device, txStream, 0, 0, 0); // start Tx streaming
else // Key went up
SoapySDRDevice_deactivateStream(soapy_sample_device, txStream, 0, 0); // stop Tx streaming
}
if ( ! soapy_KeyDown || nSamples <= 0)
return 0;
if (tx_buf_size < nSamples) {
if (tx_stream_buffer)
free(tx_stream_buffer);
tx_buf_size = nSamples * 2;
tx_stream_buffer = (complex float *)malloc(tx_buf_size * sizeof(complex float));
}
for (i = 0; i < nSamples; i++)
tx_stream_buffer[i] = cSamples[i] / CLIP16;
while (nSamples > 0) {
if (nSamples > txMTU)
count = txMTU;
else
count = nSamples;
nSamples -= count;
timeNs = 0; //+= count / tx_sample_rate * 1E9;
ret = SoapySDRDevice_writeStream(soapy_sample_device, txStream, (void *)&tx_stream_buffer, count, &flags, timeNs, data_poll_usec * 2);
if (ret < 0)
printf("Soapy writeStream fail: %s\n", SoapySDRDevice_lastError());
if (ret != count)
printf ("Soapy writeStream short write; %d < %d\n", ret, count);
//printf ("Soapy writeStream write; %i %i\n", ret, count);
}
return 0;
}
// Called to close the sample source; called from the GUI thread.
static PyObject * close_device(PyObject * self, PyObject * args)
{
int sample_device;
if (!PyArg_ParseTuple (args, "i", &sample_device))
return NULL;
if (sample_device) {
shutdown_sample_device = 1;
}
else {
if (soapy_config_device) {
SoapySDRDevice_unmake(soapy_config_device);
soapy_config_device = NULL;
}
}
Py_INCREF (Py_None);
return Py_None;
}
// Called to open the SoapySDR device; called from the GUI thread.
static PyObject * open_device(PyObject * self, PyObject * args)
{
int sample_device, poll;
const char * name;
char buf128[128];
SoapySDRDevice * sdev;
if (!PyArg_ParseTuple (args, "sii", &name, &sample_device, &poll))
return NULL;
sdev = SoapySDRDevice_makeStrArgs(name);
if(sdev) {
snprintf(buf128, 128, "Capture from %s", name);
if (sample_device) {
shutdown_sample_device = 0;
soapy_sample_device = sdev;
data_poll_usec = poll;
quisk_sample_source4(&quisk_start_samples, &quisk_stop_samples, &quisk_read_samples, &quisk_write_samples);
numTxChannels = SoapySDRDevice_getNumChannels(sdev, SOAPY_SDR_TX);
if (sample_device == 3) // disable transmit
numTxChannels = 0;
}
else {
soapy_config_device = sdev;
}
}
else {
snprintf(buf128, 128, "SoapySDRDevice_make fail: %s", SoapySDRDevice_lastError());
}
return PyString_FromString(buf128);
}
static void get_direc_len(const char * name, int * direction, int * length)
{ // return the direction (Rx or Tx) and length of name to compare
*length = strlen(name);
*direction = SOAPY_SDR_RX;
if (*length < 4)
return;
if (name[*length - 1] == 'x' && name[*length - 3] == '_') { // ends in "_rx" or "_tx"
if (name[*length - 2] == 't')
*direction = SOAPY_SDR_TX;
*length -= 3;
}
}
// Get a list of SoapySDR devices
static PyObject * get_device_list(PyObject * self, PyObject * args) // Called from GUI thread
{
PyObject * devices;
PyObject * dict;
size_t length, i, j;
SoapySDRKwargs * results;
if (!PyArg_ParseTuple (args, ""))
return NULL;
devices = PyList_New(0);
results = SoapySDRDevice_enumerate(NULL, &length);
for (i = 0; i < length; i++) {
dict = PyDict_New();
for (j = 0; j < results[i].size; j++)
PyDict_SetItemString(dict, results[i].keys[j], PyString_FromString(results[i].vals[j]));
PyList_Append(devices, dict);
Py_DECREF(dict);
}
SoapySDRKwargsList_clear(results, length);
return devices;
}
static PyObject * set_parameter(PyObject * self, PyObject * args) // Called from GUI thread
{ // Parameter name can end in "_rx" or "_tx" to specify direction.
int direction, length;
const char * param; // name of the parameter
const char * name2; // string data or sub-parameter name if any
double datum; // floating point value if any
bool is_true;
char msg200[200];
if (!PyArg_ParseTuple (args, "ssd", &param, &name2, &datum))
return NULL;
if (DEBUG)
printf ("Set %s - %s - %lf\n", param, name2, datum);
get_direc_len(param, &direction, &length);
msg200[0] = 0;
if (soapy_sample_device) {
if (numTxChannels <= 0 && direction == SOAPY_SDR_TX) {
}
//else if (direction == SOAPY_SDR_TX) {
//}
else if ( ! strcmp(param, "soapy_FDX")) {
if (datum)
soapy_FDX = 1;
else
soapy_FDX = 0;
}
else if ( ! strncmp(param, "soapy_setAntenna", length)) { // do not set empty string
if (name2[0] && SoapySDRDevice_setAntenna(soapy_sample_device, direction, 0, name2) != 0)
snprintf(msg200, 200, "%s fail: %s\n", param, SoapySDRDevice_lastError());
}
else if ( ! strncmp(param, "soapy_setBandwidth", length)) {
if (soapy_sample_device && SoapySDRDevice_setBandwidth(soapy_sample_device, direction, 0, datum) != 0)
snprintf(msg200, 200, "%s fail: %s\n", param, SoapySDRDevice_lastError());
}
else if ( ! strncmp(param, "soapy_setFrequency", length)) {
if (SoapySDRDevice_setFrequency(soapy_sample_device, direction, 0, datum, NULL) != 0)
snprintf(msg200, 200, "%s fail: %s\n", param, SoapySDRDevice_lastError());
}
else if ( ! strncmp(param, "soapy_setGain", length)) {
if (soapy_sample_device && SoapySDRDevice_setGain(soapy_sample_device, direction, 0, datum) != 0)
snprintf(msg200, 200, "%s fail: %s\n", param, SoapySDRDevice_lastError());
}
else if ( ! strncmp(param, "soapy_setGainElement", length)) {
if (SoapySDRDevice_setGainElement(soapy_sample_device, direction, 0, name2, datum) != 0)
snprintf(msg200, 200, "%s fail: %s\n", param, SoapySDRDevice_lastError());
}
else if ( ! strncmp(param, "soapy_setGainMode", length)) {
if ( ! strcmp(name2, "true"))
is_true = 1;
else
is_true = 0;
if (SoapySDRDevice_setGainMode(soapy_sample_device, direction, 0, is_true) != 0)
snprintf(msg200, 200, "%s fail: %s\n", param, SoapySDRDevice_lastError());
}
else if ( ! strncmp(param, "soapy_setSampleRate", length)) {
if (direction == SOAPY_SDR_RX)
rx_sample_rate = datum;
else
tx_sample_rate = datum;
if (SoapySDRDevice_setSampleRate(soapy_sample_device, direction, 0, datum) != 0)
snprintf(msg200, 200, "%s fail: %s\n", param, SoapySDRDevice_lastError());
}
else {
snprintf(msg200, 200, "Soapy set_parameter() for unknown name %s\n", param);
}
}
if (msg200[0])
return PyString_FromString(msg200);
Py_INCREF (Py_None);
return Py_None;
}
static void Range2List(SoapySDRRange range, PyObject * pylist)
{
PyObject * pyobj;
pyobj = PyFloat_FromDouble(range.minimum);
PyList_Append(pylist, pyobj);
Py_DECREF(pyobj);
pyobj = PyFloat_FromDouble(range.maximum);
PyList_Append(pylist, pyobj);
Py_DECREF(pyobj);
pyobj = PyFloat_FromDouble(range.step);
PyList_Append(pylist, pyobj);
Py_DECREF(pyobj);
}
static PyObject * get_parameter(PyObject * self, PyObject * args) // Called from GUI thread
{ // Return a SoapySDR parameter.
// Parameter name can end in "_rx" or "_tx" to specify direction.
int sample_device, direction, length;
char * name;
char ** names;
size_t i, len_list;
bool is_true;
double value;
PyObject * pylist, * pyobj, * pylst2;
SoapySDRDevice * sdev;
SoapySDRRange range;
SoapySDRRange * ranges;
if (!PyArg_ParseTuple (args, "si", &name, &sample_device))
return NULL;
if (sample_device)
sdev = soapy_sample_device;
else
sdev = soapy_config_device;
get_direc_len(name, &direction, &length);
if ( ! sdev) {
;
}
else if ( ! strncmp(name, "soapy_listAntennas", length)) {
pylist = PyList_New(0);
names = SoapySDRDevice_listAntennas(sdev, direction, 0, &len_list);
for (i = 0; i < len_list; i++) {
pyobj = PyString_FromString(names[i]);
PyList_Append(pylist, pyobj);
Py_DECREF(pyobj);
}
SoapySDRStrings_clear(&names, len_list);
return pylist;
}
else if ( ! strncmp(name, "soapy_getBandwidth", length)) {
value = SoapySDRDevice_getBandwidth(sdev, direction, 0);
return PyFloat_FromDouble(value);
}
else if ( ! strncmp(name, "soapy_getBandwidthRange", length)) {
pylist = PyList_New(0);
ranges = SoapySDRDevice_getBandwidthRange(sdev, direction, 0, &len_list);
for (i = 0; i < len_list; i++) {
pylst2 = PyList_New(0);
range = ranges[i];
Range2List(range, pylst2);
PyList_Append(pylist, pylst2);
Py_DECREF(pylst2);
}
return pylist;
}
else if ( ! strncmp(name, "soapy_getFullDuplex", length)) {
is_true = SoapySDRDevice_getFullDuplex(sdev, direction, 0);
if (is_true)
return PyInt_FromLong(1);
else
return PyInt_FromLong(0);
}
else if ( ! strncmp(name, "soapy_getGainRange", length)) {
pylist = PyList_New(0);
range = SoapySDRDevice_getGainRange(sdev, direction, 0);
Range2List(range, pylist);
return pylist;
}
else if ( ! strncmp(name, "soapy_getSampleRate", length)) {
value = SoapySDRDevice_getSampleRate(sdev, direction, 0);
return PyFloat_FromDouble(value);
}
else if ( ! strncmp(name, "soapy_getSampleRateRange", length)) {
pylist = PyList_New(0);
ranges = SoapySDRDevice_getSampleRateRange(sdev, direction, 0, &len_list);
for (i = 0; i < len_list; i++) {
pylst2 = PyList_New(0);
range = ranges[i];
Range2List(range, pylst2);
PyList_Append(pylist, pylst2);
Py_DECREF(pylst2);
}
return pylist;
}
else if ( ! strncmp(name, "soapy_hasGainMode", length)) {
is_true = SoapySDRDevice_hasGainMode(sdev, direction, 0);
if (is_true)
return PyInt_FromLong(1);
else
return PyInt_FromLong(0);
}
else if ( ! strncmp(name, "soapy_listGains", length)) {
pylist = PyList_New(0);
names = SoapySDRDevice_listGains(sdev, direction, 0, &len_list);
for (i = 0; i < len_list; i++) {
pyobj = PyString_FromString(names[i]);
PyList_Append(pylist, pyobj);
Py_DECREF(pyobj);
}
SoapySDRStrings_clear(&names, len_list);
return pylist;
}
else if ( ! strncmp(name, "soapy_listGainsValues", length)) {
pylist = PyList_New(0);
pylst2 = PyList_New(0); // First element is the total gain
pyobj = PyString_FromString("total");
PyList_Append(pylst2, pyobj);
Py_DECREF(pyobj);
range = SoapySDRDevice_getGainRange(sdev, direction, 0);
Range2List(range, pylst2);
PyList_Append(pylist, pylst2);
Py_DECREF(pylst2);
names = SoapySDRDevice_listGains(sdev, direction, 0, &len_list);
for (i = 0; i < len_list; i++) {
pylst2 = PyList_New(0);
pyobj = PyString_FromString(names[i]);
PyList_Append(pylst2, pyobj);
Py_DECREF(pyobj);
range = SoapySDRDevice_getGainElementRange(sdev, direction, 0, names[i]);
Range2List(range, pylst2);
PyList_Append(pylist, pylst2);
Py_DECREF(pylst2);
}
SoapySDRStrings_clear(&names, len_list);
return pylist;
}
else {
printf("Soapy get_parameter() for unknown name %s\n", name);
}
Py_INCREF (Py_None);
return Py_None;
}
// Functions callable from Python are listed here:
static PyMethodDef QuiskMethods[] = {
{"open_device", open_device, METH_VARARGS, "Open the hardware."},
{"close_device", close_device, METH_VARARGS, "Close the hardware"},
{"get_device_list", get_device_list, METH_VARARGS, "Return a list of SoapySDR devices"},
{"get_parameter", get_parameter, METH_VARARGS, "Get a SoapySDR parameter"},
{"set_parameter", set_parameter, METH_VARARGS, "Set a SoapySDR parameter"},
{NULL, NULL, 0, NULL} /* Sentinel */
};
#if PY_MAJOR_VERSION < 3
// Python 2.7:
// Initialization, and registration of public symbol "initsoapy":
PyMODINIT_FUNC initsoapy (void)
{
if (Py_InitModule ("soapy", QuiskMethods) == NULL) {
printf("Py_InitModule failed!\n");
return;
}
// Import pointers to functions and variables from module _quisk
if (import_quisk_api()) {
printf("Failure to import pointers from _quisk\n");
return; //Error
}
}
// Python 3:
#else
static struct PyModuleDef soapymodule = {
PyModuleDef_HEAD_INIT,
"soapy",
NULL,
-1,
QuiskMethods
} ;
PyMODINIT_FUNC PyInit_soapy(void)
{
PyObject * m;
m = PyModule_Create(&soapymodule);
if (m == NULL)
return NULL;
// Import pointers to functions and variables from module _quisk
if (import_quisk_api()) {
printf("Failure to import pointers from _quisk\n");
return m; //Error
}
return m;
}
#endif
Reference in New Issue View Git Blame Copy Permalink