kopia lustrzana https://github.com/cariboulabs/cariboulite
added ads-b example
rodzic
046191ca02
commit
6720e3969a
|
@ -19,8 +19,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
|
|||
########################################################################
|
||||
add_executable(caribou_dump1090
|
||||
dump1090.cpp
|
||||
# SoapySDRProbe.cpp
|
||||
# SoapyRateTest.cpp
|
||||
modes.c
|
||||
)
|
||||
|
||||
target_link_libraries(caribou_dump1090 SoapySDR)
|
||||
|
|
|
@ -1,174 +0,0 @@
|
|||
// Copyright (c) 2016-2017 Josh Blum
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <SoapySDR/Device.hpp>
|
||||
#include <SoapySDR/Formats.hpp>
|
||||
#include <SoapySDR/Errors.hpp>
|
||||
#include <string>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
#include <csignal>
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
|
||||
static sig_atomic_t loopDone = false;
|
||||
static void sigIntHandler(const int)
|
||||
{
|
||||
loopDone = true;
|
||||
}
|
||||
|
||||
void runRateTestStreamLoop(
|
||||
SoapySDR::Device *device,
|
||||
SoapySDR::Stream *stream,
|
||||
const int direction,
|
||||
const size_t numChans,
|
||||
const size_t elemSize)
|
||||
{
|
||||
//allocate buffers for the stream read/write
|
||||
const size_t numElems = device->getStreamMTU(stream);
|
||||
std::vector<std::vector<char>> buffMem(numChans, std::vector<char>(elemSize*numElems));
|
||||
std::vector<void *> buffs(numChans);
|
||||
for (size_t i = 0; i < numChans; i++) buffs[i] = buffMem[i].data();
|
||||
|
||||
//state collected in this loop
|
||||
unsigned int overflows(0);
|
||||
unsigned int underflows(0);
|
||||
unsigned long long totalSamples(0);
|
||||
const auto startTime = std::chrono::high_resolution_clock::now();
|
||||
auto timeLastPrint = std::chrono::high_resolution_clock::now();
|
||||
auto timeLastSpin = std::chrono::high_resolution_clock::now();
|
||||
auto timeLastStatus = std::chrono::high_resolution_clock::now();
|
||||
int spinIndex(0);
|
||||
|
||||
std::cout << "Starting stream loop, press Ctrl+C to exit..." << std::endl;
|
||||
device->activateStream(stream);
|
||||
signal(SIGINT, sigIntHandler);
|
||||
while (not loopDone)
|
||||
{
|
||||
int ret(0);
|
||||
int flags(0);
|
||||
long long timeNs(0);
|
||||
switch(direction)
|
||||
{
|
||||
case SOAPY_SDR_RX:
|
||||
ret = device->readStream(stream, buffs.data(), numElems, flags, timeNs);
|
||||
break;
|
||||
case SOAPY_SDR_TX:
|
||||
ret = device->writeStream(stream, buffs.data(), numElems, flags, timeNs);
|
||||
break;
|
||||
}
|
||||
|
||||
if (ret == SOAPY_SDR_TIMEOUT) continue;
|
||||
if (ret == SOAPY_SDR_OVERFLOW)
|
||||
{
|
||||
overflows++;
|
||||
continue;
|
||||
}
|
||||
if (ret == SOAPY_SDR_UNDERFLOW)
|
||||
{
|
||||
underflows++;
|
||||
continue;
|
||||
}
|
||||
if (ret < 0)
|
||||
{
|
||||
std::cerr << "Unexpected stream error " << SoapySDR::errToStr(ret) << std::endl;
|
||||
break;
|
||||
}
|
||||
totalSamples += ret;
|
||||
|
||||
const auto now = std::chrono::high_resolution_clock::now();
|
||||
if (timeLastSpin + std::chrono::milliseconds(300) < now)
|
||||
{
|
||||
timeLastSpin = now;
|
||||
static const char spin[] = {"|/-\\"};
|
||||
printf("\b%c", spin[(spinIndex++)%4]);
|
||||
fflush(stdout);
|
||||
}
|
||||
//occasionally read out the stream status (non blocking)
|
||||
if (timeLastStatus + std::chrono::seconds(1) < now)
|
||||
{
|
||||
timeLastStatus = now;
|
||||
while (true)
|
||||
{
|
||||
size_t chanMask; int flags; long long timeNs;
|
||||
ret = device->readStreamStatus(stream, chanMask, flags, timeNs, 0);
|
||||
if (ret == SOAPY_SDR_OVERFLOW) overflows++;
|
||||
else if (ret == SOAPY_SDR_UNDERFLOW) underflows++;
|
||||
else if (ret == SOAPY_SDR_TIME_ERROR) {}
|
||||
else break;
|
||||
}
|
||||
}
|
||||
if (timeLastPrint + std::chrono::seconds(5) < now)
|
||||
{
|
||||
timeLastPrint = now;
|
||||
const auto timePassed = std::chrono::duration_cast<std::chrono::microseconds>(now - startTime);
|
||||
const auto sampleRate = double(totalSamples)/timePassed.count();
|
||||
printf("\b%g Msps\t%g MBps", sampleRate, sampleRate*numChans*elemSize);
|
||||
if (overflows != 0) printf("\tOverflows %u", overflows);
|
||||
if (underflows != 0) printf("\tUnderflows %u", underflows);
|
||||
printf("\n ");
|
||||
}
|
||||
|
||||
}
|
||||
device->deactivateStream(stream);
|
||||
}
|
||||
|
||||
int SoapySDRRateTest(
|
||||
const std::string &argStr,
|
||||
const double sampleRate,
|
||||
const std::string &formatStr,
|
||||
const std::string &channelStr,
|
||||
const std::string &directionStr)
|
||||
{
|
||||
SoapySDR::Device *device(nullptr);
|
||||
|
||||
try
|
||||
{
|
||||
device = SoapySDR::Device::make(argStr);
|
||||
|
||||
//parse the direction to the integer enum
|
||||
int direction(-1);
|
||||
if (directionStr == "RX" or directionStr == "rx") direction = SOAPY_SDR_RX;
|
||||
if (directionStr == "TX" or directionStr == "tx") direction = SOAPY_SDR_TX;
|
||||
if (direction == -1) throw std::invalid_argument("direction not in RX/TX: " + directionStr);
|
||||
|
||||
//build channels list, using KwargsFromString is a easy parsing hack
|
||||
std::vector<size_t> channels;
|
||||
for (const auto &pair : SoapySDR::KwargsFromString(channelStr))
|
||||
{
|
||||
channels.push_back(std::stoi(pair.first));
|
||||
}
|
||||
if (channels.empty()) channels.push_back(0);
|
||||
|
||||
//initialize the sample rate for all channels
|
||||
for (const auto &chan : channels)
|
||||
{
|
||||
device->setSampleRate(direction, chan, sampleRate);
|
||||
}
|
||||
|
||||
//create the stream, use the native format
|
||||
double fullScale(0.0);
|
||||
const auto format = formatStr.empty() ? device->getNativeStreamFormat(direction, channels.front(), fullScale) : formatStr;
|
||||
const size_t elemSize = SoapySDR::formatToSize(format);
|
||||
auto stream = device->setupStream(direction, format, channels);
|
||||
|
||||
//run the rate test one setup is complete
|
||||
std::cout << "Stream format: " << format << std::endl;
|
||||
std::cout << "Num channels: " << channels.size() << std::endl;
|
||||
std::cout << "Element size: " << elemSize << " bytes" << std::endl;
|
||||
std::cout << "Begin " << directionStr << " rate test at " << (sampleRate/1e6) << " Msps" << std::endl;
|
||||
runRateTestStreamLoop(device, stream, direction, channels.size(), elemSize);
|
||||
|
||||
//cleanup stream and device
|
||||
device->closeStream(stream);
|
||||
SoapySDR::Device::unmake(device);
|
||||
}
|
||||
catch (const std::exception &ex)
|
||||
{
|
||||
std::cerr << "Error in rate test: " << ex.what() << std::endl;
|
||||
SoapySDR::Device::unmake(device);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
return EXIT_FAILURE;
|
||||
}
|
|
@ -1,336 +0,0 @@
|
|||
// Copyright (c) 2015-2017 Josh Blum
|
||||
// Copyright (c) 2016-2016 Bastille Networks
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <SoapySDR/Device.hpp>
|
||||
#include <sstream>
|
||||
#include <limits>
|
||||
|
||||
template <typename Type>
|
||||
std::string toString(const std::vector<Type> &options)
|
||||
{
|
||||
std::stringstream ss;
|
||||
if (options.empty()) return "";
|
||||
for (size_t i = 0; i < options.size(); i++)
|
||||
{
|
||||
if (not ss.str().empty()) ss << ", ";
|
||||
ss << options[i];
|
||||
}
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string toString(const SoapySDR::Range &range)
|
||||
{
|
||||
std::stringstream ss;
|
||||
ss << "[" << range.minimum() << ", " << range.maximum();
|
||||
if (range.step() != 0.0) ss << ", " << range.step();
|
||||
ss << "]";
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string toString(const SoapySDR::RangeList &range, const double scale)
|
||||
{
|
||||
const size_t MAXRLEN = 10; //for abbreviating long lists
|
||||
std::stringstream ss;
|
||||
for (size_t i = 0; i < range.size(); i++)
|
||||
{
|
||||
if (range.size() >= MAXRLEN and i >= MAXRLEN/2 and i < (range.size()-MAXRLEN/2))
|
||||
{
|
||||
if (i == MAXRLEN) ss << ", ...";
|
||||
continue;
|
||||
}
|
||||
if (not ss.str().empty()) ss << ", ";
|
||||
if (range[i].minimum() == range[i].maximum()) ss << (range[i].minimum()/scale);
|
||||
else ss << "[" << (range[i].minimum()/scale) << ", " << (range[i].maximum()/scale) << "]";
|
||||
}
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string toString(const std::vector<double> &nums, const double scale)
|
||||
{
|
||||
std::stringstream ss;
|
||||
|
||||
if (nums.size() > 3)
|
||||
{
|
||||
ss << "[" << (nums.front()/scale) << ", " << (nums.back()/scale) << "]";
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < nums.size(); i++)
|
||||
{
|
||||
if (not ss.str().empty()) ss << ", ";
|
||||
ss << (nums[i]/scale);
|
||||
}
|
||||
return "[" + ss.str() + "]";
|
||||
}
|
||||
|
||||
std::string toString(const SoapySDR::ArgInfo &argInfo, const std::string indent = " ")
|
||||
{
|
||||
std::stringstream ss;
|
||||
|
||||
//name, or use key if missing
|
||||
std::string name = argInfo.name;
|
||||
if (argInfo.name.empty()) name = argInfo.key;
|
||||
ss << indent << " * " << name;
|
||||
|
||||
//optional description
|
||||
std::string desc = argInfo.description;
|
||||
const std::string replace("\n"+indent+" ");
|
||||
for (size_t pos = 0; (pos=desc.find("\n", pos)) != std::string::npos; pos+=replace.size())
|
||||
{
|
||||
desc.replace(pos, 1, replace);
|
||||
}
|
||||
if (not desc.empty()) ss << " - " << desc << std::endl << indent << " ";
|
||||
|
||||
//other fields
|
||||
ss << " [key=" << argInfo.key;
|
||||
if (not argInfo.units.empty()) ss << ", units=" << argInfo.units;
|
||||
if (not argInfo.value.empty()) ss << ", default=" << argInfo.value;
|
||||
|
||||
//type
|
||||
switch (argInfo.type)
|
||||
{
|
||||
case SoapySDR::ArgInfo::BOOL: ss << ", type=bool"; break;
|
||||
case SoapySDR::ArgInfo::INT: ss << ", type=int"; break;
|
||||
case SoapySDR::ArgInfo::FLOAT: ss << ", type=float"; break;
|
||||
case SoapySDR::ArgInfo::STRING: ss << ", type=string"; break;
|
||||
}
|
||||
|
||||
//optional range/enumeration
|
||||
if (argInfo.range.minimum() < argInfo.range.maximum()) ss << ", range=" << toString(argInfo.range);
|
||||
if (not argInfo.options.empty()) ss << ", options=(" << toString(argInfo.options) << ")";
|
||||
|
||||
ss << "]";
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string toString(const SoapySDR::ArgInfoList &argInfos)
|
||||
{
|
||||
std::stringstream ss;
|
||||
|
||||
for (size_t i = 0; i < argInfos.size(); i++)
|
||||
{
|
||||
ss << toString(argInfos[i]) << std::endl;
|
||||
}
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string sensorReadings(SoapySDR::Device *device)
|
||||
{
|
||||
std::stringstream ss;
|
||||
|
||||
/*******************************************************************
|
||||
* Sensor readings
|
||||
******************************************************************/
|
||||
std::vector<std::string> sensors = device->listSensors();
|
||||
|
||||
for (size_t i = 0; i < sensors.size(); i++)
|
||||
{
|
||||
std::string key = sensors[i];
|
||||
SoapySDR::ArgInfo info = device->getSensorInfo(key);
|
||||
std::string reading = device->readSensor(key);
|
||||
|
||||
ss << " * " << sensors[i];
|
||||
if (not info.name.empty()) ss << " (" << info.name << ")";
|
||||
ss << ":";
|
||||
if (info.range.maximum() > std::numeric_limits<double>::min()) ss << toString(info.range);
|
||||
ss << toString(info.options);
|
||||
ss << " " << reading;
|
||||
if (not info.units.empty()) ss << " " << info.units;
|
||||
ss << std::endl;
|
||||
if (not info.description.empty()) ss << " " << info.description << std::endl;
|
||||
}
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string channelSensorReadings(SoapySDR::Device *device, const int dir, const size_t chan)
|
||||
{
|
||||
std::stringstream ss;
|
||||
|
||||
/*******************************************************************
|
||||
* Channel sensor readings
|
||||
******************************************************************/
|
||||
std::vector<std::string> sensors = device->listSensors(dir, chan);
|
||||
|
||||
for (size_t i = 0; i < sensors.size(); i++)
|
||||
{
|
||||
std::string key = sensors[i];
|
||||
SoapySDR::ArgInfo info = device->getSensorInfo(dir, chan, key);
|
||||
std::string reading = device->readSensor(dir, chan, key);
|
||||
|
||||
ss << " * " << sensors[i];
|
||||
if (not info.name.empty()) ss << " (" << info.name << ")";
|
||||
ss << ":";
|
||||
if (info.range.maximum() > std::numeric_limits<double>::min()) ss << toString(info.range);
|
||||
ss << toString(info.options);
|
||||
ss << " " << reading;
|
||||
if (not info.units.empty()) ss << " " << info.units;
|
||||
ss << std::endl;
|
||||
if (not info.description.empty()) ss << " " << info.description << std::endl;
|
||||
}
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
static std::string probeChannel(SoapySDR::Device *device, const int dir, const size_t chan)
|
||||
{
|
||||
std::stringstream ss;
|
||||
|
||||
std::string dirName = (dir==SOAPY_SDR_TX)?"TX":"RX";
|
||||
ss << std::endl;
|
||||
ss << "----------------------------------------------------" << std::endl;
|
||||
ss << "-- " << dirName << " Channel " << chan << std::endl;
|
||||
ss << "----------------------------------------------------" << std::endl;
|
||||
|
||||
// info
|
||||
const auto info = device->getChannelInfo(dir, chan);
|
||||
if (info.size() > 0)
|
||||
{
|
||||
ss << " Channel Information:" << std::endl;
|
||||
for (const auto &it : info)
|
||||
{
|
||||
ss << " " << it.first << "=" << it.second << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
ss << " Full-duplex: " << (device->getFullDuplex(dir, chan)?"YES":"NO") << std::endl;
|
||||
ss << " Supports AGC: " << (device->hasGainMode(dir, chan)?"YES":"NO") << std::endl;
|
||||
|
||||
//formats
|
||||
std::string formats = toString(device->getStreamFormats(dir, chan));
|
||||
if (not formats.empty()) ss << " Stream formats: " << formats << std::endl;
|
||||
|
||||
//native
|
||||
double fullScale = 0.0;
|
||||
std::string native = device->getNativeStreamFormat(dir, chan, fullScale);
|
||||
ss << " Native format: " << native << " [full-scale=" << fullScale << "]" << std::endl;
|
||||
|
||||
//stream args
|
||||
std::string streamArgs = toString(device->getStreamArgsInfo(dir, chan));
|
||||
if (not streamArgs.empty()) ss << " Stream args:" << std::endl << streamArgs;
|
||||
|
||||
//antennas
|
||||
std::string antennas = toString(device->listAntennas(dir, chan));
|
||||
if (not antennas.empty()) ss << " Antennas: " << antennas << std::endl;
|
||||
|
||||
//corrections
|
||||
std::vector<std::string> correctionsList;
|
||||
if (device->hasDCOffsetMode(dir, chan)) correctionsList.push_back("DC removal");
|
||||
if (device->hasDCOffset(dir, chan)) correctionsList.push_back("DC offset");
|
||||
if (device->hasIQBalance(dir, chan)) correctionsList.push_back("IQ balance");
|
||||
std::string corrections = toString(correctionsList);
|
||||
if (not corrections.empty()) ss << " Corrections: " << corrections << std::endl;
|
||||
|
||||
//gains
|
||||
ss << " Full gain range: " << toString(device->getGainRange(dir, chan)) << " dB" << std::endl;
|
||||
std::vector<std::string> gainsList = device->listGains(dir, chan);
|
||||
for (size_t i = 0; i < gainsList.size(); i++)
|
||||
{
|
||||
const std::string name = gainsList[i];
|
||||
ss << " " << name << " gain range: " << toString(device->getGainRange(dir, chan, name)) << " dB" << std::endl;
|
||||
}
|
||||
|
||||
//frequencies
|
||||
ss << " Full freq range: " << toString(device->getFrequencyRange(dir, chan), 1e6) << " MHz" << std::endl;
|
||||
std::vector<std::string> freqsList = device->listFrequencies(dir, chan);
|
||||
for (size_t i = 0; i < freqsList.size(); i++)
|
||||
{
|
||||
const std::string name = freqsList[i];
|
||||
ss << " " << name << " freq range: " << toString(device->getFrequencyRange(dir, chan, name), 1e6) << " MHz" << std::endl;
|
||||
}
|
||||
|
||||
//freq args
|
||||
std::string freqArgs = toString(device->getFrequencyArgsInfo(dir, chan));
|
||||
if (not freqArgs.empty()) ss << " Tune args:" << std::endl << freqArgs;
|
||||
|
||||
//rates
|
||||
ss << " Sample rates: " << toString(device->getSampleRateRange(dir, chan), 1e6) << " MSps" << std::endl;
|
||||
|
||||
//bandwidths
|
||||
const auto bws = device->getBandwidthRange(dir, chan);
|
||||
if (not bws.empty()) ss << " Filter bandwidths: " << toString(bws, 1e6) << " MHz" << std::endl;
|
||||
|
||||
//sensors
|
||||
std::string sensors = toString(device->listSensors(dir, chan));
|
||||
if (not sensors.empty()) ss << " Sensors: " << sensors << std::endl;
|
||||
ss << channelSensorReadings(device, dir, chan);
|
||||
|
||||
//settings
|
||||
std::string settings = toString(device->getSettingInfo(dir, chan));
|
||||
if (not settings.empty()) ss << " Other Settings:" << std::endl << settings;
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string SoapySDRDeviceProbe(SoapySDR::Device *device)
|
||||
{
|
||||
std::stringstream ss;
|
||||
|
||||
/*******************************************************************
|
||||
* Identification info
|
||||
******************************************************************/
|
||||
ss << std::endl;
|
||||
ss << "----------------------------------------------------" << std::endl;
|
||||
ss << "-- Device identification" << std::endl;
|
||||
ss << "----------------------------------------------------" << std::endl;
|
||||
|
||||
ss << " driver=" << device->getDriverKey() << std::endl;
|
||||
ss << " hardware=" << device->getHardwareKey() << std::endl;
|
||||
for (const auto &it : device->getHardwareInfo())
|
||||
{
|
||||
ss << " " << it.first << "=" << it.second << std::endl;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
* Available peripherals
|
||||
******************************************************************/
|
||||
ss << std::endl;
|
||||
ss << "----------------------------------------------------" << std::endl;
|
||||
ss << "-- Peripheral summary" << std::endl;
|
||||
ss << "----------------------------------------------------" << std::endl;
|
||||
|
||||
size_t numRxChans = device->getNumChannels(SOAPY_SDR_RX);
|
||||
size_t numTxChans = device->getNumChannels(SOAPY_SDR_TX);
|
||||
ss << " Channels: " << numRxChans << " Rx, " << numTxChans << " Tx" << std::endl;
|
||||
|
||||
ss << " Timestamps: " << (device->hasHardwareTime()?"YES":"NO") << std::endl;
|
||||
|
||||
std::string clockSources = toString(device->listClockSources());
|
||||
if (not clockSources.empty()) ss << " Clock sources: " << clockSources << std::endl;
|
||||
|
||||
std::string timeSources = toString(device->listTimeSources());
|
||||
if (not timeSources.empty()) ss << " Time sources: " << timeSources << std::endl;
|
||||
|
||||
std::string sensors = toString(device->listSensors());
|
||||
if (not sensors.empty()) ss << " Sensors: " << sensors << std::endl;
|
||||
ss << sensorReadings(device);
|
||||
|
||||
std::string registers = toString(device->listRegisterInterfaces());
|
||||
if (not registers.empty()) ss << " Registers: " << registers << std::endl;
|
||||
|
||||
std::string settings = toString(device->getSettingInfo());
|
||||
if (not settings.empty()) ss << " Other Settings:" << std::endl << settings;
|
||||
|
||||
std::string gpios = toString(device->listGPIOBanks());
|
||||
if (not gpios.empty()) ss << " GPIOs: " << gpios << std::endl;
|
||||
|
||||
std::string uarts = toString(device->listUARTs());
|
||||
if (not uarts.empty()) ss << " UARTs: " << uarts << std::endl;
|
||||
|
||||
/*******************************************************************
|
||||
* Per-channel info
|
||||
******************************************************************/
|
||||
for (size_t chan = 0; chan < numRxChans; chan++)
|
||||
{
|
||||
ss << probeChannel(device, SOAPY_SDR_RX, chan);
|
||||
}
|
||||
for (size_t chan = 0; chan < numTxChans; chan++)
|
||||
{
|
||||
ss << probeChannel(device, SOAPY_SDR_TX, chan);
|
||||
}
|
||||
|
||||
return ss.str();
|
||||
}
|
|
@ -11,86 +11,20 @@ set(CMAKE_MAKEFILE_DEPENDS
|
|||
"CMakeFiles/3.18.4/CMakeCCompiler.cmake"
|
||||
"CMakeFiles/3.18.4/CMakeCXXCompiler.cmake"
|
||||
"CMakeFiles/3.18.4/CMakeSystem.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeCCompiler.cmake.in"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeCCompilerABI.c"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeCInformation.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeCXXCompiler.cmake.in"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeCXXCompilerABI.cpp"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeCXXInformation.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeCommonLanguageInclude.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeCompilerIdDetection.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeDetermineCCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeDetermineCXXCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeDetermineCompileFeatures.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeDetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeDetermineCompilerABI.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeDetermineCompilerId.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeDetermineSystem.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeFindBinUtils.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeGenericSystem.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeInitializeConfigs.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeLanguageInformation.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeParseImplicitIncludeInfo.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeParseImplicitLinkInfo.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeSystem.cmake.in"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeSystemSpecificInformation.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeSystemSpecificInitialize.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeTestCCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeTestCXXCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeTestCompilerCommon.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/CMakeUnixFindMake.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/ADSP-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/ARMCC-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/ARMClang-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/AppleClang-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Borland-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Bruce-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Clang-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Compaq-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Cray-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Embarcadero-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Fujitsu-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/GHS-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/GNU-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/GNU-C.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/GNU-CXX.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/GNU-FindBinUtils.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/GNU.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/HP-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/HP-CXX-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/IAR-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Intel-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/MSVC-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/NVIDIA-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/PGI-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/PathScale-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/SCO-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/SDCC-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/SunPro-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/TI-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/Watcom-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/XL-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/XL-CXX-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/XLClang-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/zOS-C-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Internal/CMakeCheckCompilerFlag.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Internal/FeatureTesting.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Platform/Linux-Determine-CXX.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Platform/Linux-GNU-C.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Platform/Linux-GNU-CXX.cmake"
|
||||
"/usr/share/cmake-3.18/Modules/Platform/Linux-GNU.cmake"
|
||||
|
@ -106,11 +40,6 @@ set(CMAKE_MAKEFILE_OUTPUTS
|
|||
|
||||
# Byproducts of CMake generate step:
|
||||
set(CMAKE_MAKEFILE_PRODUCTS
|
||||
"CMakeFiles/3.18.4/CMakeSystem.cmake"
|
||||
"CMakeFiles/3.18.4/CMakeCCompiler.cmake"
|
||||
"CMakeFiles/3.18.4/CMakeCXXCompiler.cmake"
|
||||
"CMakeFiles/3.18.4/CMakeCCompiler.cmake"
|
||||
"CMakeFiles/3.18.4/CMakeCXXCompiler.cmake"
|
||||
"CMakeFiles/CMakeDirectoryInformation.cmake"
|
||||
)
|
||||
|
||||
|
|
|
@ -93,12 +93,12 @@ clean: CMakeFiles/caribou_dump1090.dir/clean
|
|||
CMakeFiles/caribou_dump1090.dir/all:
|
||||
$(MAKE) $(MAKESILENT) -f CMakeFiles/caribou_dump1090.dir/build.make CMakeFiles/caribou_dump1090.dir/depend
|
||||
$(MAKE) $(MAKESILENT) -f CMakeFiles/caribou_dump1090.dir/build.make CMakeFiles/caribou_dump1090.dir/build
|
||||
@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles --progress-num=1,2 "Built target caribou_dump1090"
|
||||
@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles --progress-num=1,2,3 "Built target caribou_dump1090"
|
||||
.PHONY : CMakeFiles/caribou_dump1090.dir/all
|
||||
|
||||
# Build rule for subdir invocation for target.
|
||||
CMakeFiles/caribou_dump1090.dir/rule: cmake_check_build_system
|
||||
$(CMAKE_COMMAND) -E cmake_progress_start /home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles 2
|
||||
$(CMAKE_COMMAND) -E cmake_progress_start /home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles 3
|
||||
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/caribou_dump1090.dir/all
|
||||
$(CMAKE_COMMAND) -E cmake_progress_start /home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles 0
|
||||
.PHONY : CMakeFiles/caribou_dump1090.dir/rule
|
||||
|
|
|
@ -0,0 +1,8 @@
|
|||
#IncludeRegexLine: ^[ ]*[#%][ ]*(include|import)[ ]*[<"]([^">]+)([">])
|
||||
|
||||
#IncludeRegexScan: ^.*$
|
||||
|
||||
#IncludeRegexComplain: ^$
|
||||
|
||||
#IncludeRegexTransform:
|
||||
|
|
@ -39,4 +39,20 @@ sys/types.h
|
|||
-
|
||||
sys/stat.h
|
||||
-
|
||||
modes.h
|
||||
/home/pi/projects/cariboulite/examples/cpp/modes.h
|
||||
|
||||
/home/pi/projects/cariboulite/examples/cpp/modes.h
|
||||
string.h
|
||||
-
|
||||
stdlib.h
|
||||
-
|
||||
stdint.h
|
||||
-
|
||||
unistd.h
|
||||
-
|
||||
math.h
|
||||
-
|
||||
sys/time.h
|
||||
-
|
||||
|
||||
|
|
|
@ -1,8 +1,17 @@
|
|||
# The set of languages for which implicit dependencies are needed:
|
||||
set(CMAKE_DEPENDS_LANGUAGES
|
||||
"C"
|
||||
"CXX"
|
||||
)
|
||||
# The set of files for implicit dependencies of each language:
|
||||
set(CMAKE_DEPENDS_CHECK_C
|
||||
"/home/pi/projects/cariboulite/examples/cpp/modes.c" "/home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles/caribou_dump1090.dir/modes.c.o"
|
||||
)
|
||||
set(CMAKE_C_COMPILER_ID "GNU")
|
||||
|
||||
# The include file search paths:
|
||||
set(CMAKE_C_TARGET_INCLUDE_PATH
|
||||
)
|
||||
set(CMAKE_DEPENDS_CHECK_CXX
|
||||
"/home/pi/projects/cariboulite/examples/cpp/dump1090.cpp" "/home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o"
|
||||
)
|
||||
|
|
|
@ -89,17 +89,32 @@ CMakeFiles/caribou_dump1090.dir/dump1090.cpp.s: cmake_force
|
|||
@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/caribou_dump1090.dir/dump1090.cpp.s"
|
||||
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/pi/projects/cariboulite/examples/cpp/dump1090.cpp -o CMakeFiles/caribou_dump1090.dir/dump1090.cpp.s
|
||||
|
||||
CMakeFiles/caribou_dump1090.dir/modes.c.o: CMakeFiles/caribou_dump1090.dir/flags.make
|
||||
CMakeFiles/caribou_dump1090.dir/modes.c.o: ../modes.c
|
||||
@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building C object CMakeFiles/caribou_dump1090.dir/modes.c.o"
|
||||
/usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/caribou_dump1090.dir/modes.c.o -c /home/pi/projects/cariboulite/examples/cpp/modes.c
|
||||
|
||||
CMakeFiles/caribou_dump1090.dir/modes.c.i: cmake_force
|
||||
@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/caribou_dump1090.dir/modes.c.i"
|
||||
/usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/pi/projects/cariboulite/examples/cpp/modes.c > CMakeFiles/caribou_dump1090.dir/modes.c.i
|
||||
|
||||
CMakeFiles/caribou_dump1090.dir/modes.c.s: cmake_force
|
||||
@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/caribou_dump1090.dir/modes.c.s"
|
||||
/usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/pi/projects/cariboulite/examples/cpp/modes.c -o CMakeFiles/caribou_dump1090.dir/modes.c.s
|
||||
|
||||
# Object files for target caribou_dump1090
|
||||
caribou_dump1090_OBJECTS = \
|
||||
"CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o"
|
||||
"CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o" \
|
||||
"CMakeFiles/caribou_dump1090.dir/modes.c.o"
|
||||
|
||||
# External object files for target caribou_dump1090
|
||||
caribou_dump1090_EXTERNAL_OBJECTS =
|
||||
|
||||
caribou_dump1090: CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o
|
||||
caribou_dump1090: CMakeFiles/caribou_dump1090.dir/modes.c.o
|
||||
caribou_dump1090: CMakeFiles/caribou_dump1090.dir/build.make
|
||||
caribou_dump1090: CMakeFiles/caribou_dump1090.dir/link.txt
|
||||
@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable caribou_dump1090"
|
||||
@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/pi/projects/cariboulite/examples/cpp/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking CXX executable caribou_dump1090"
|
||||
$(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/caribou_dump1090.dir/link.txt --verbose=$(VERBOSE)
|
||||
|
||||
# Rule to build all files generated by this target.
|
||||
|
|
|
@ -1,10 +1,11 @@
|
|||
file(REMOVE_RECURSE
|
||||
"CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o"
|
||||
"CMakeFiles/caribou_dump1090.dir/modes.c.o"
|
||||
"caribou_dump1090"
|
||||
"caribou_dump1090.pdb"
|
||||
)
|
||||
|
||||
# Per-language clean rules from dependency scanning.
|
||||
foreach(lang CXX)
|
||||
foreach(lang C CXX)
|
||||
include(CMakeFiles/caribou_dump1090.dir/cmake_clean_${lang}.cmake OPTIONAL)
|
||||
endforeach()
|
||||
|
|
|
@ -1,5 +1,9 @@
|
|||
# CMAKE generated file: DO NOT EDIT!
|
||||
# Generated by "Unix Makefiles" Generator, CMake Version 3.18
|
||||
|
||||
CMakeFiles/caribou_dump1090.dir/modes.c.o
|
||||
/home/pi/projects/cariboulite/examples/cpp/modes.c
|
||||
/home/pi/projects/cariboulite/examples/cpp/modes.h
|
||||
CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o
|
||||
/home/pi/projects/cariboulite/examples/cpp/dump1090.cpp
|
||||
/home/pi/projects/cariboulite/examples/cpp/modes.h
|
||||
|
|
|
@ -1,5 +1,9 @@
|
|||
# CMAKE generated file: DO NOT EDIT!
|
||||
# Generated by "Unix Makefiles" Generator, CMake Version 3.18
|
||||
|
||||
CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o: ../dump1090.cpp
|
||||
CMakeFiles/caribou_dump1090.dir/modes.c.o: ../modes.c
|
||||
CMakeFiles/caribou_dump1090.dir/modes.c.o: ../modes.h
|
||||
|
||||
CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o: ../dump1090.cpp
|
||||
CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o: ../modes.h
|
||||
|
||||
|
|
|
@ -1,7 +1,14 @@
|
|||
# CMAKE generated file: DO NOT EDIT!
|
||||
# Generated by "Unix Makefiles" Generator, CMake Version 3.18
|
||||
|
||||
# compile C with /usr/bin/cc
|
||||
# compile CXX with /usr/bin/c++
|
||||
C_DEFINES =
|
||||
|
||||
C_INCLUDES =
|
||||
|
||||
C_FLAGS = -O3 -DNDEBUG -fPIE
|
||||
|
||||
CXX_DEFINES =
|
||||
|
||||
CXX_INCLUDES =
|
||||
|
|
|
@ -1 +1 @@
|
|||
/usr/bin/c++ -O3 -DNDEBUG CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o -o caribou_dump1090 -lSoapySDR
|
||||
/usr/bin/c++ -O3 -DNDEBUG CMakeFiles/caribou_dump1090.dir/dump1090.cpp.o CMakeFiles/caribou_dump1090.dir/modes.c.o -o caribou_dump1090 -lSoapySDR
|
||||
|
|
|
@ -1,3 +1,4 @@
|
|||
CMAKE_PROGRESS_1 = 1
|
||||
CMAKE_PROGRESS_2 = 2
|
||||
CMAKE_PROGRESS_3 = 3
|
||||
|
||||
|
|
|
@ -1 +1 @@
|
|||
2
|
||||
3
|
||||
|
|
|
@ -169,6 +169,33 @@ dump1090.cpp.s:
|
|||
$(MAKE) $(MAKESILENT) -f CMakeFiles/caribou_dump1090.dir/build.make CMakeFiles/caribou_dump1090.dir/dump1090.cpp.s
|
||||
.PHONY : dump1090.cpp.s
|
||||
|
||||
modes.o: modes.c.o
|
||||
|
||||
.PHONY : modes.o
|
||||
|
||||
# target to build an object file
|
||||
modes.c.o:
|
||||
$(MAKE) $(MAKESILENT) -f CMakeFiles/caribou_dump1090.dir/build.make CMakeFiles/caribou_dump1090.dir/modes.c.o
|
||||
.PHONY : modes.c.o
|
||||
|
||||
modes.i: modes.c.i
|
||||
|
||||
.PHONY : modes.i
|
||||
|
||||
# target to preprocess a source file
|
||||
modes.c.i:
|
||||
$(MAKE) $(MAKESILENT) -f CMakeFiles/caribou_dump1090.dir/build.make CMakeFiles/caribou_dump1090.dir/modes.c.i
|
||||
.PHONY : modes.c.i
|
||||
|
||||
modes.s: modes.c.s
|
||||
|
||||
.PHONY : modes.s
|
||||
|
||||
# target to generate assembly for a file
|
||||
modes.c.s:
|
||||
$(MAKE) $(MAKESILENT) -f CMakeFiles/caribou_dump1090.dir/build.make CMakeFiles/caribou_dump1090.dir/modes.c.s
|
||||
.PHONY : modes.c.s
|
||||
|
||||
# Help Target
|
||||
help:
|
||||
@echo "The following are some of the valid targets for this Makefile:"
|
||||
|
@ -181,6 +208,9 @@ help:
|
|||
@echo "... dump1090.o"
|
||||
@echo "... dump1090.i"
|
||||
@echo "... dump1090.s"
|
||||
@echo "... modes.o"
|
||||
@echo "... modes.i"
|
||||
@echo "... modes.s"
|
||||
.PHONY : help
|
||||
|
||||
|
||||
|
|
Plik binarny nie jest wyświetlany.
|
@ -1,12 +1,10 @@
|
|||
// Copyright (c) 2014-2021 Josh Blum
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <SoapySDR/Version.hpp>
|
||||
#include <SoapySDR/Modules.hpp>
|
||||
#include <SoapySDR/Registry.hpp>
|
||||
#include <SoapySDR/Device.hpp>
|
||||
#include <SoapySDR/ConverterRegistry.hpp>
|
||||
#include <algorithm> //sort, min, max
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <cstddef>
|
||||
#include <iostream>
|
||||
|
@ -17,15 +15,7 @@
|
|||
#include <getopt.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
std::string SoapySDRDeviceProbe(SoapySDR::Device *);
|
||||
std::string sensorReadings(SoapySDR::Device *);
|
||||
int SoapySDRRateTest(
|
||||
const std::string &argStr,
|
||||
const double sampleRate,
|
||||
const std::string &formatStr,
|
||||
const std::string &channelStr,
|
||||
const std::string &directionStr);
|
||||
#include "modes.h"
|
||||
|
||||
/***********************************************************************
|
||||
* Print the banner
|
||||
|
@ -70,6 +60,11 @@ static void sigIntHandler(const int)
|
|||
loopDone = true;
|
||||
}
|
||||
|
||||
void onModeSMessage(mode_s_t *self, struct mode_s_msg *mm)
|
||||
{
|
||||
printf("Got message from flight %s at altitude %d\n", mm->flight, mm->altitude);
|
||||
}
|
||||
|
||||
void runSoapyProcess(
|
||||
SoapySDR::Device *device,
|
||||
SoapySDR::Stream *stream,
|
||||
|
@ -80,20 +75,14 @@ void runSoapyProcess(
|
|||
//allocate buffers for the stream read/write
|
||||
const size_t numElems = device->getStreamMTU(stream);
|
||||
std::vector<std::vector<char>> buffMem(numChans, std::vector<char>(elemSize*numElems));
|
||||
std::vector<unsigned short> magMem(numElems);
|
||||
std::vector<void *> buffs(numChans);
|
||||
for (size_t i = 0; i < numChans; i++) buffs[i] = buffMem[i].data();
|
||||
|
||||
//state collected in this loop
|
||||
unsigned int overflows(0);
|
||||
unsigned int underflows(0);
|
||||
unsigned long long totalSamples(0);
|
||||
const auto startTime = std::chrono::high_resolution_clock::now();
|
||||
auto timeLastPrint = std::chrono::high_resolution_clock::now();
|
||||
auto timeLastSpin = std::chrono::high_resolution_clock::now();
|
||||
auto timeLastStatus = std::chrono::high_resolution_clock::now();
|
||||
int spinIndex(0);
|
||||
// MODE-S Stuff
|
||||
mode_s_t state;
|
||||
mode_s_init(&state);
|
||||
|
||||
std::cout << "Num Elements / read = " << numElems << std::endl;
|
||||
std::cout << "Starting stream loop, press Ctrl+C to exit..." << std::endl;
|
||||
device->activateStream(stream);
|
||||
signal(SIGINT, sigIntHandler);
|
||||
|
@ -107,12 +96,12 @@ void runSoapyProcess(
|
|||
if (ret == SOAPY_SDR_TIMEOUT) continue;
|
||||
if (ret == SOAPY_SDR_OVERFLOW)
|
||||
{
|
||||
overflows++;
|
||||
//overflows++;
|
||||
continue;
|
||||
}
|
||||
if (ret == SOAPY_SDR_UNDERFLOW)
|
||||
{
|
||||
underflows++;
|
||||
//underflows++;
|
||||
continue;
|
||||
}
|
||||
if (ret < 0)
|
||||
|
@ -120,47 +109,19 @@ void runSoapyProcess(
|
|||
std::cerr << "Unexpected stream error " << ret << std::endl;
|
||||
break;
|
||||
}
|
||||
//std::cout << ret << std::endl;
|
||||
totalSamples += ret;
|
||||
//totalSamples += ret;
|
||||
|
||||
const auto now = std::chrono::high_resolution_clock::now();
|
||||
/*if (timeLastSpin + std::chrono::milliseconds(300) < now)
|
||||
{
|
||||
timeLastSpin = now;
|
||||
static const char spin[] = {"|/-\\"};
|
||||
printf("\b%c", spin[(spinIndex++)%4]);
|
||||
fflush(stdout);
|
||||
}*/
|
||||
// compute the magnitude of the signal
|
||||
mode_s_compute_magnitude_vector((short*)(buffs[0]), magMem.data(), ret);
|
||||
|
||||
//occasionally read out the stream status (non blocking)
|
||||
if (timeLastStatus + std::chrono::seconds(1) < now)
|
||||
{
|
||||
timeLastStatus = now;
|
||||
while (true)
|
||||
{
|
||||
size_t chanMask; int flags; long long timeNs;
|
||||
ret = device->readStreamStatus(stream, chanMask, flags, timeNs, 0);
|
||||
if (ret == SOAPY_SDR_OVERFLOW) overflows++;
|
||||
else if (ret == SOAPY_SDR_UNDERFLOW) underflows++;
|
||||
else if (ret == SOAPY_SDR_TIME_ERROR) {}
|
||||
else break;
|
||||
}
|
||||
}
|
||||
if (timeLastPrint + std::chrono::seconds(5) < now)
|
||||
{
|
||||
timeLastPrint = now;
|
||||
const auto timePassed = std::chrono::duration_cast<std::chrono::microseconds>(now - startTime);
|
||||
const auto sampleRate = double(totalSamples)/timePassed.count();
|
||||
printf("\b%g Msps\t%g MBps", sampleRate, sampleRate*numChans*elemSize);
|
||||
if (overflows != 0) printf("\tOverflows %u", overflows);
|
||||
if (underflows != 0) printf("\tUnderflows %u", underflows);
|
||||
printf("\n ");
|
||||
}
|
||||
// detect Mode S messages in the signal and call on_msg with each message
|
||||
mode_s_detect(&state, magMem.data(), ret, onModeSMessage);
|
||||
|
||||
}
|
||||
device->deactivateStream(stream);
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* Main entry point
|
||||
**********************************************************************/
|
||||
|
@ -184,9 +145,10 @@ int main(int argc, char *argv[])
|
|||
|
||||
// set the sample rate
|
||||
device->setSampleRate(SOAPY_SDR_RX, channels[0], 4e6);
|
||||
|
||||
//create the stream, use the native format
|
||||
|
||||
device->setBandwidth(SOAPY_SDR_RX, channels[0], 2500e3);
|
||||
device->setGainMode(SOAPY_SDR_RX, channels[0], true);
|
||||
|
||||
//create the stream, use the native format
|
||||
const auto format = device->getNativeStreamFormat(SOAPY_SDR_RX, channels.front(), fullScale);
|
||||
const size_t elemSize = SoapySDR::formatToSize(format);
|
||||
auto stream = device->setupStream(SOAPY_SDR_RX, format, channels);
|
||||
|
|
|
@ -0,0 +1,747 @@
|
|||
#include "modes.h"
|
||||
|
||||
#define MODE_S_PREAMBLE_US 8 // microseconds
|
||||
#define MODE_S_LONG_MSG_BITS 112
|
||||
#define MODE_S_SHORT_MSG_BITS 56
|
||||
#define MODE_S_FULL_LEN (MODE_S_PREAMBLE_US+MODE_S_LONG_MSG_BITS)
|
||||
|
||||
#define MODE_S_ICAO_CACHE_TTL 60 // Time to live of cached addresses.
|
||||
|
||||
static uint16_t maglut[129*129*2];
|
||||
static int maglut_initialized = 0;
|
||||
|
||||
// =============================== Initialization ===========================
|
||||
|
||||
void mode_s_init(mode_s_t *self) {
|
||||
int i, q;
|
||||
|
||||
self->fix_errors = 1;
|
||||
self->check_crc = 1;
|
||||
self->aggressive = 0;
|
||||
|
||||
// Allocate the ICAO address cache. We use two uint32_t for every entry
|
||||
// because it's a addr / timestamp pair for every entry
|
||||
memset(&self->icao_cache, 0, sizeof(self->icao_cache));
|
||||
|
||||
// Populate the I/Q -> Magnitude lookup table. It is used because sqrt or
|
||||
// round may be expensive and may vary a lot depending on the libc used.
|
||||
//
|
||||
// We scale to 0-255 range multiplying by 1.4 in order to ensure that every
|
||||
// different I/Q pair will result in a different magnitude value, not losing
|
||||
// any resolution.
|
||||
if (!maglut_initialized) {
|
||||
for (i = 0; i <= 128; i++) {
|
||||
for (q = 0; q <= 128; q++) {
|
||||
maglut[i*129+q] = round(sqrt(i*i+q*q)*360);
|
||||
}
|
||||
}
|
||||
maglut_initialized = 1;
|
||||
}
|
||||
}
|
||||
|
||||
// ===================== Mode S detection and decoding =====================
|
||||
|
||||
// Parity table for MODE S Messages.
|
||||
//
|
||||
// The table contains 112 elements, every element corresponds to a bit set in
|
||||
// the message, starting from the first bit of actual data after the preamble.
|
||||
//
|
||||
// For messages of 112 bit, the whole table is used. For messages of 56 bits
|
||||
// only the last 56 elements are used.
|
||||
//
|
||||
// The algorithm is as simple as xoring all the elements in this table for
|
||||
// which the corresponding bit on the message is set to 1.
|
||||
//
|
||||
// The latest 24 elements in this table are set to 0 as the checksum at the end
|
||||
// of the message should not affect the computation.
|
||||
//
|
||||
// Note: this function can be used with DF11 and DF17, other modes have the CRC
|
||||
// xored with the sender address as they are reply to interrogations, but a
|
||||
// casual listener can't split the address from the checksum.
|
||||
uint32_t mode_s_checksum_table[] = {
|
||||
0x3935ea, 0x1c9af5, 0xf1b77e, 0x78dbbf, 0xc397db, 0x9e31e9, 0xb0e2f0, 0x587178,
|
||||
0x2c38bc, 0x161c5e, 0x0b0e2f, 0xfa7d13, 0x82c48d, 0xbe9842, 0x5f4c21, 0xd05c14,
|
||||
0x682e0a, 0x341705, 0xe5f186, 0x72f8c3, 0xc68665, 0x9cb936, 0x4e5c9b, 0xd8d449,
|
||||
0x939020, 0x49c810, 0x24e408, 0x127204, 0x093902, 0x049c81, 0xfdb444, 0x7eda22,
|
||||
0x3f6d11, 0xe04c8c, 0x702646, 0x381323, 0xe3f395, 0x8e03ce, 0x4701e7, 0xdc7af7,
|
||||
0x91c77f, 0xb719bb, 0xa476d9, 0xadc168, 0x56e0b4, 0x2b705a, 0x15b82d, 0xf52612,
|
||||
0x7a9309, 0xc2b380, 0x6159c0, 0x30ace0, 0x185670, 0x0c2b38, 0x06159c, 0x030ace,
|
||||
0x018567, 0xff38b7, 0x80665f, 0xbfc92b, 0xa01e91, 0xaff54c, 0x57faa6, 0x2bfd53,
|
||||
0xea04ad, 0x8af852, 0x457c29, 0xdd4410, 0x6ea208, 0x375104, 0x1ba882, 0x0dd441,
|
||||
0xf91024, 0x7c8812, 0x3e4409, 0xe0d800, 0x706c00, 0x383600, 0x1c1b00, 0x0e0d80,
|
||||
0x0706c0, 0x038360, 0x01c1b0, 0x00e0d8, 0x00706c, 0x003836, 0x001c1b, 0xfff409,
|
||||
0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
|
||||
0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
|
||||
0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000
|
||||
};
|
||||
|
||||
uint32_t mode_s_checksum(unsigned char *msg, int bits) {
|
||||
uint32_t crc = 0;
|
||||
int offset = (bits == 112) ? 0 : (112-56);
|
||||
int j;
|
||||
|
||||
for(j = 0; j < bits; j++) {
|
||||
int byte = j/8;
|
||||
int bit = j%8;
|
||||
int bitmask = 1 << (7-bit);
|
||||
|
||||
// If bit is set, xor with corresponding table entry.
|
||||
if (msg[byte] & bitmask)
|
||||
crc ^= mode_s_checksum_table[j+offset];
|
||||
}
|
||||
return crc; // 24 bit checksum.
|
||||
}
|
||||
|
||||
// Given the Downlink Format (DF) of the message, return the message length in
|
||||
// bits.
|
||||
int mode_s_msg_len_by_type(int type) {
|
||||
if (type == 16 || type == 17 ||
|
||||
type == 19 || type == 20 ||
|
||||
type == 21)
|
||||
return MODE_S_LONG_MSG_BITS;
|
||||
else
|
||||
return MODE_S_SHORT_MSG_BITS;
|
||||
}
|
||||
|
||||
// Try to fix single bit errors using the checksum. On success modifies the
|
||||
// original buffer with the fixed version, and returns the position of the
|
||||
// error bit. Otherwise if fixing failed -1 is returned.
|
||||
int fix_single_bit_errors(unsigned char *msg, int bits) {
|
||||
int j;
|
||||
unsigned char aux[MODE_S_LONG_MSG_BITS/8];
|
||||
|
||||
for (j = 0; j < bits; j++) {
|
||||
int byte = j/8;
|
||||
int bitmask = 1 << (7-(j%8));
|
||||
uint32_t crc1, crc2;
|
||||
|
||||
memcpy(aux, msg, bits/8);
|
||||
aux[byte] ^= bitmask; // Flip j-th bit.
|
||||
|
||||
crc1 = ((uint32_t)aux[(bits/8)-3] << 16) |
|
||||
((uint32_t)aux[(bits/8)-2] << 8) |
|
||||
(uint32_t)aux[(bits/8)-1];
|
||||
crc2 = mode_s_checksum(aux, bits);
|
||||
|
||||
if (crc1 == crc2) {
|
||||
// The error is fixed. Overwrite the original buffer with the
|
||||
// corrected sequence, and returns the error bit position.
|
||||
memcpy(msg, aux, bits/8);
|
||||
return j;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Similar to fix_single_bit_errors() but try every possible two bit
|
||||
// combination. This is very slow and should be tried only against DF17
|
||||
// messages that don't pass the checksum, and only in Aggressive Mode.
|
||||
int fix_two_bits_errors(unsigned char *msg, int bits) {
|
||||
int j, i;
|
||||
unsigned char aux[MODE_S_LONG_MSG_BITS/8];
|
||||
|
||||
for (j = 0; j < bits; j++) {
|
||||
int byte1 = j/8;
|
||||
int bitmask1 = 1 << (7-(j%8));
|
||||
|
||||
// Don't check the same pairs multiple times, so i starts from j+1
|
||||
for (i = j+1; i < bits; i++) {
|
||||
int byte2 = i/8;
|
||||
int bitmask2 = 1 << (7-(i%8));
|
||||
uint32_t crc1, crc2;
|
||||
|
||||
memcpy(aux, msg, bits/8);
|
||||
|
||||
aux[byte1] ^= bitmask1; // Flip j-th bit.
|
||||
aux[byte2] ^= bitmask2; // Flip i-th bit.
|
||||
|
||||
crc1 = ((uint32_t)aux[(bits/8)-3] << 16) |
|
||||
((uint32_t)aux[(bits/8)-2] << 8) |
|
||||
(uint32_t)aux[(bits/8)-1];
|
||||
crc2 = mode_s_checksum(aux, bits);
|
||||
|
||||
if (crc1 == crc2) {
|
||||
// The error is fixed. Overwrite the original buffer with the
|
||||
// corrected sequence, and returns the error bit position.
|
||||
memcpy(msg, aux, bits/8);
|
||||
// We return the two bits as a 16 bit integer by shifting 'i'
|
||||
// on the left. This is possible since 'i' will always be
|
||||
// non-zero because i starts from j+1.
|
||||
return j | (i<<8);
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Hash the ICAO address to index our cache of MODE_S_ICAO_CACHE_LEN elements,
|
||||
// that is assumed to be a power of two.
|
||||
uint32_t icao_cache_has_addr(uint32_t a) {
|
||||
// The following three rounds wil make sure that every bit affects every
|
||||
// output bit with ~ 50% of probability.
|
||||
a = ((a >> 16) ^ a) * 0x45d9f3b;
|
||||
a = ((a >> 16) ^ a) * 0x45d9f3b;
|
||||
a = ((a >> 16) ^ a);
|
||||
return a & (MODE_S_ICAO_CACHE_LEN-1);
|
||||
}
|
||||
|
||||
// Add the specified entry to the cache of recently seen ICAO addresses. Note
|
||||
// that we also add a timestamp so that we can make sure that the entry is only
|
||||
// valid for MODE_S_ICAO_CACHE_TTL seconds.
|
||||
void add_recently_seen_icao_addr(mode_s_t *self, uint32_t addr) {
|
||||
uint32_t h = icao_cache_has_addr(addr);
|
||||
self->icao_cache[h*2] = addr;
|
||||
self->icao_cache[h*2+1] = (uint32_t) time(NULL);
|
||||
}
|
||||
|
||||
// Returns 1 if the specified ICAO address was seen in a DF format with proper
|
||||
// checksum (not xored with address) no more than * MODE_S_ICAO_CACHE_TTL
|
||||
// seconds ago. Otherwise returns 0.
|
||||
int icao_addr_was_recently_seen(mode_s_t *self, uint32_t addr) {
|
||||
uint32_t h = icao_cache_has_addr(addr);
|
||||
uint32_t a = self->icao_cache[h*2];
|
||||
int32_t t = self->icao_cache[h*2+1];
|
||||
|
||||
return a && a == addr && time(NULL)-t <= MODE_S_ICAO_CACHE_TTL;
|
||||
}
|
||||
|
||||
// If the message type has the checksum xored with the ICAO address, try to
|
||||
// brute force it using a list of recently seen ICAO addresses.
|
||||
//
|
||||
// Do this in a brute-force fashion by xoring the predicted CRC with the
|
||||
// address XOR checksum field in the message. This will recover the address: if
|
||||
// we found it in our cache, we can assume the message is ok.
|
||||
//
|
||||
// This function expects mm->msgtype and mm->msgbits to be correctly populated
|
||||
// by the caller.
|
||||
//
|
||||
// On success the correct ICAO address is stored in the mode_s_msg structure in
|
||||
// the aa3, aa2, and aa1 fiedls.
|
||||
//
|
||||
// If the function successfully recovers a message with a correct checksum it
|
||||
// returns 1. Otherwise 0 is returned.
|
||||
int brute_force_ap(mode_s_t *self, unsigned char *msg, struct mode_s_msg *mm) {
|
||||
unsigned char aux[MODE_S_LONG_MSG_BYTES];
|
||||
int msgtype = mm->msgtype;
|
||||
int msgbits = mm->msgbits;
|
||||
|
||||
if (msgtype == 0 || // Short air surveillance
|
||||
msgtype == 4 || // Surveillance, altitude reply
|
||||
msgtype == 5 || // Surveillance, identity reply
|
||||
msgtype == 16 || // Long Air-Air survillance
|
||||
msgtype == 20 || // Comm-A, altitude request
|
||||
msgtype == 21 || // Comm-A, identity request
|
||||
msgtype == 24) // Comm-C ELM
|
||||
{
|
||||
uint32_t addr;
|
||||
uint32_t crc;
|
||||
int lastbyte = (msgbits/8)-1;
|
||||
|
||||
// Work on a copy.
|
||||
memcpy(aux, msg, msgbits/8);
|
||||
|
||||
// Compute the CRC of the message and XOR it with the AP field so that
|
||||
// we recover the address, because:
|
||||
//
|
||||
// (ADDR xor CRC) xor CRC = ADDR.
|
||||
crc = mode_s_checksum(aux, msgbits);
|
||||
aux[lastbyte] ^= crc & 0xff;
|
||||
aux[lastbyte-1] ^= (crc >> 8) & 0xff;
|
||||
aux[lastbyte-2] ^= (crc >> 16) & 0xff;
|
||||
|
||||
// If the obtained address exists in our cache we consider the message
|
||||
// valid.
|
||||
addr = aux[lastbyte] | (aux[lastbyte-1] << 8) | (aux[lastbyte-2] << 16);
|
||||
if (icao_addr_was_recently_seen(self, addr)) {
|
||||
mm->aa1 = aux[lastbyte-2];
|
||||
mm->aa2 = aux[lastbyte-1];
|
||||
mm->aa3 = aux[lastbyte];
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Decode the 13 bit AC altitude field (in DF 20 and others). Returns the
|
||||
// altitude, and set 'unit' to either MODE_S_UNIT_METERS or MDOES_UNIT_FEETS.
|
||||
int decode_ac13_field(unsigned char *msg, int *unit) {
|
||||
int m_bit = msg[3] & (1<<6);
|
||||
int q_bit = msg[3] & (1<<4);
|
||||
|
||||
if (!m_bit) {
|
||||
*unit = MODE_S_UNIT_FEET;
|
||||
if (q_bit) {
|
||||
// N is the 11 bit integer resulting from the removal of bit Q and M
|
||||
int n = ((msg[2]&31)<<6) |
|
||||
((msg[3]&0x80)>>2) |
|
||||
((msg[3]&0x20)>>1) |
|
||||
(msg[3]&15);
|
||||
// The final altitude is due to the resulting number multiplied by
|
||||
// 25, minus 1000.
|
||||
return n*25-1000;
|
||||
} else {
|
||||
// TODO: Implement altitude where Q=0 and M=0
|
||||
}
|
||||
} else {
|
||||
*unit = MODE_S_UNIT_METERS;
|
||||
// TODO: Implement altitude when meter unit is selected.
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Decode the 12 bit AC altitude field (in DF 17 and others). Returns the
|
||||
// altitude or 0 if it can't be decoded.
|
||||
int decode_ac12_field(unsigned char *msg, int *unit) {
|
||||
int q_bit = msg[5] & 1;
|
||||
|
||||
if (q_bit) {
|
||||
// N is the 11 bit integer resulting from the removal of bit Q
|
||||
*unit = MODE_S_UNIT_FEET;
|
||||
int n = ((msg[5]>>1)<<4) | ((msg[6]&0xF0) >> 4);
|
||||
// The final altitude is due to the resulting number multiplied by 25,
|
||||
// minus 1000.
|
||||
return n*25-1000;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static const char *ais_charset = "?ABCDEFGHIJKLMNOPQRSTUVWXYZ????? ???????????????0123456789??????";
|
||||
|
||||
// Decode a raw Mode S message demodulated as a stream of bytes by
|
||||
// mode_s_detect(), and split it into fields populating a mode_s_msg structure.
|
||||
void mode_s_decode(mode_s_t *self, struct mode_s_msg *mm, unsigned char *msg) {
|
||||
uint32_t crc2; // Computed CRC, used to verify the message CRC.
|
||||
|
||||
// Work on our local copy
|
||||
memcpy(mm->msg, msg, MODE_S_LONG_MSG_BYTES);
|
||||
msg = mm->msg;
|
||||
|
||||
// Get the message type ASAP as other operations depend on this
|
||||
mm->msgtype = msg[0]>>3; // Downlink Format
|
||||
mm->msgbits = mode_s_msg_len_by_type(mm->msgtype);
|
||||
|
||||
// CRC is always the last three bytes.
|
||||
mm->crc = ((uint32_t)msg[(mm->msgbits/8)-3] << 16) |
|
||||
((uint32_t)msg[(mm->msgbits/8)-2] << 8) |
|
||||
(uint32_t)msg[(mm->msgbits/8)-1];
|
||||
crc2 = mode_s_checksum(msg, mm->msgbits);
|
||||
|
||||
// Check CRC and fix single bit errors using the CRC when possible (DF 11 and 17).
|
||||
mm->errorbit = -1; // No error
|
||||
mm->crcok = (mm->crc == crc2);
|
||||
|
||||
if (!mm->crcok && self->fix_errors && (mm->msgtype == 11 || mm->msgtype == 17)) {
|
||||
if ((mm->errorbit = fix_single_bit_errors(msg, mm->msgbits)) != -1) {
|
||||
mm->crc = mode_s_checksum(msg, mm->msgbits);
|
||||
mm->crcok = 1;
|
||||
} else if (self->aggressive && mm->msgtype == 17 &&
|
||||
(mm->errorbit = fix_two_bits_errors(msg, mm->msgbits)) != -1) {
|
||||
mm->crc = mode_s_checksum(msg, mm->msgbits);
|
||||
mm->crcok = 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Note that most of the other computation happens *after* we fix the
|
||||
// single bit errors, otherwise we would need to recompute the fields
|
||||
// again.
|
||||
mm->ca = msg[0] & 7; // Responder capabilities.
|
||||
|
||||
// ICAO address
|
||||
mm->aa1 = msg[1];
|
||||
mm->aa2 = msg[2];
|
||||
mm->aa3 = msg[3];
|
||||
|
||||
// DF 17 type (assuming this is a DF17, otherwise not used)
|
||||
mm->metype = msg[4] >> 3; // Extended squitter message type.
|
||||
mm->mesub = msg[4] & 7; // Extended squitter message subtype.
|
||||
|
||||
// Fields for DF4,5,20,21
|
||||
mm->fs = msg[0] & 7; // Flight status for DF4,5,20,21
|
||||
mm->dr = msg[1] >> 3 & 31; // Request extraction of downlink request.
|
||||
mm->um = ((msg[1] & 7)<<3)| // Request extraction of downlink request.
|
||||
msg[2]>>5;
|
||||
|
||||
// In the squawk (identity) field bits are interleaved like that (message
|
||||
// bit 20 to bit 32):
|
||||
//
|
||||
// C1-A1-C2-A2-C4-A4-ZERO-B1-D1-B2-D2-B4-D4
|
||||
//
|
||||
// So every group of three bits A, B, C, D represent an integer from 0 to
|
||||
// 7.
|
||||
//
|
||||
// The actual meaning is just 4 octal numbers, but we convert it into a
|
||||
// base ten number tha happens to represent the four octal numbers.
|
||||
//
|
||||
// For more info: http://en.wikipedia.org/wiki/Gillham_code
|
||||
{
|
||||
int a, b, c, d;
|
||||
|
||||
a = ((msg[3] & 0x80) >> 5) |
|
||||
((msg[2] & 0x02) >> 0) |
|
||||
((msg[2] & 0x08) >> 3);
|
||||
b = ((msg[3] & 0x02) << 1) |
|
||||
((msg[3] & 0x08) >> 2) |
|
||||
((msg[3] & 0x20) >> 5);
|
||||
c = ((msg[2] & 0x01) << 2) |
|
||||
((msg[2] & 0x04) >> 1) |
|
||||
((msg[2] & 0x10) >> 4);
|
||||
d = ((msg[3] & 0x01) << 2) |
|
||||
((msg[3] & 0x04) >> 1) |
|
||||
((msg[3] & 0x10) >> 4);
|
||||
mm->identity = a*1000 + b*100 + c*10 + d;
|
||||
}
|
||||
|
||||
// DF 11 & 17: try to populate our ICAO addresses whitelist. DFs with an AP
|
||||
// field (xored addr and crc), try to decode it.
|
||||
if (mm->msgtype != 11 && mm->msgtype != 17) {
|
||||
// Check if we can check the checksum for the Downlink Formats where
|
||||
// the checksum is xored with the aircraft ICAO address. We try to
|
||||
// brute force it using a list of recently seen aircraft addresses.
|
||||
if (brute_force_ap(self, msg, mm)) {
|
||||
// We recovered the message, mark the checksum as valid.
|
||||
mm->crcok = 1;
|
||||
} else {
|
||||
mm->crcok = 0;
|
||||
}
|
||||
} else {
|
||||
// If this is DF 11 or DF 17 and the checksum was ok, we can add this
|
||||
// address to the list of recently seen addresses.
|
||||
if (mm->crcok && mm->errorbit == -1) {
|
||||
uint32_t addr = (mm->aa1 << 16) | (mm->aa2 << 8) | mm->aa3;
|
||||
add_recently_seen_icao_addr(self, addr);
|
||||
}
|
||||
}
|
||||
|
||||
// Decode 13 bit altitude for DF0, DF4, DF16, DF20
|
||||
if (mm->msgtype == 0 || mm->msgtype == 4 ||
|
||||
mm->msgtype == 16 || mm->msgtype == 20) {
|
||||
mm->altitude = decode_ac13_field(msg, &mm->unit);
|
||||
}
|
||||
|
||||
// Decode extended squitter specific stuff.
|
||||
if (mm->msgtype == 17) {
|
||||
// Decode the extended squitter message.
|
||||
|
||||
if (mm->metype >= 1 && mm->metype <= 4) {
|
||||
// Aircraft Identification and Category
|
||||
mm->aircraft_type = mm->metype-1;
|
||||
mm->flight[0] = (ais_charset)[msg[5]>>2];
|
||||
mm->flight[1] = ais_charset[((msg[5]&3)<<4)|(msg[6]>>4)];
|
||||
mm->flight[2] = ais_charset[((msg[6]&15)<<2)|(msg[7]>>6)];
|
||||
mm->flight[3] = ais_charset[msg[7]&63];
|
||||
mm->flight[4] = ais_charset[msg[8]>>2];
|
||||
mm->flight[5] = ais_charset[((msg[8]&3)<<4)|(msg[9]>>4)];
|
||||
mm->flight[6] = ais_charset[((msg[9]&15)<<2)|(msg[10]>>6)];
|
||||
mm->flight[7] = ais_charset[msg[10]&63];
|
||||
mm->flight[8] = '\0';
|
||||
} else if (mm->metype >= 9 && mm->metype <= 18) {
|
||||
// Airborne position Message
|
||||
mm->fflag = msg[6] & (1<<2);
|
||||
mm->tflag = msg[6] & (1<<3);
|
||||
mm->altitude = decode_ac12_field(msg, &mm->unit);
|
||||
mm->raw_latitude = ((msg[6] & 3) << 15) |
|
||||
(msg[7] << 7) |
|
||||
(msg[8] >> 1);
|
||||
mm->raw_longitude = ((msg[8]&1) << 16) |
|
||||
(msg[9] << 8) |
|
||||
msg[10];
|
||||
} else if (mm->metype == 19 && mm->mesub >= 1 && mm->mesub <= 4) {
|
||||
// Airborne Velocity Message
|
||||
if (mm->mesub == 1 || mm->mesub == 2) {
|
||||
mm->ew_dir = (msg[5]&4) >> 2;
|
||||
mm->ew_velocity = ((msg[5]&3) << 8) | msg[6];
|
||||
mm->ns_dir = (msg[7]&0x80) >> 7;
|
||||
mm->ns_velocity = ((msg[7]&0x7f) << 3) | ((msg[8]&0xe0) >> 5);
|
||||
mm->vert_rate_source = (msg[8]&0x10) >> 4;
|
||||
mm->vert_rate_sign = (msg[8]&0x8) >> 3;
|
||||
mm->vert_rate = ((msg[8]&7) << 6) | ((msg[9]&0xfc) >> 2);
|
||||
// Compute velocity and angle from the two speed components
|
||||
mm->velocity = sqrt(mm->ns_velocity*mm->ns_velocity+
|
||||
mm->ew_velocity*mm->ew_velocity);
|
||||
if (mm->velocity) {
|
||||
int ewv = mm->ew_velocity;
|
||||
int nsv = mm->ns_velocity;
|
||||
double heading;
|
||||
|
||||
if (mm->ew_dir) ewv *= -1;
|
||||
if (mm->ns_dir) nsv *= -1;
|
||||
heading = atan2(ewv, nsv);
|
||||
|
||||
// Convert to degrees.
|
||||
mm->heading = heading * 360 / (M_PI*2);
|
||||
// We don't want negative values but a 0-360 scale.
|
||||
if (mm->heading < 0) mm->heading += 360;
|
||||
} else {
|
||||
mm->heading = 0;
|
||||
}
|
||||
} else if (mm->mesub == 3 || mm->mesub == 4) {
|
||||
mm->heading_is_valid = msg[5] & (1<<2);
|
||||
mm->heading = (360.0/128) * (((msg[5] & 3) << 5) |
|
||||
(msg[6] >> 3));
|
||||
}
|
||||
}
|
||||
}
|
||||
mm->phase_corrected = 0; // Set to 1 by the caller if needed.
|
||||
}
|
||||
|
||||
// Turn I/Q samples pointed by `data` into the magnitude vector pointed by `mag`
|
||||
void mode_s_compute_magnitude_vector(short *data, uint16_t *mag, uint32_t size)
|
||||
{
|
||||
uint32_t j;
|
||||
|
||||
// Compute the magnitude vector. It's just SQRT(I^2 + Q^2), but we rescale
|
||||
// to the 0-255 range to exploit the full resolution.
|
||||
/*for (j = 0; j < size; j += 2) {
|
||||
int i = data[j]-127;
|
||||
int q = data[j+1]-127;
|
||||
|
||||
if (i < 0) i = -i;
|
||||
if (q < 0) q = -q;
|
||||
mag[j/2] = maglut[i*129+q];
|
||||
}*/
|
||||
for (j=0; j<size; j+=2)
|
||||
{
|
||||
int i = data[j];
|
||||
int q = data[j+1];
|
||||
mag[j/2]=sqrt(i*i + q*q);
|
||||
}
|
||||
}
|
||||
|
||||
// Return -1 if the message is out of fase left-side
|
||||
// Return 1 if the message is out of fase right-size
|
||||
// Return 0 if the message is not particularly out of phase.
|
||||
//
|
||||
// Note: this function will access mag[-1], so the caller should make sure to
|
||||
// call it only if we are not at the start of the current buffer.
|
||||
int detect_out_of_phase(uint16_t *mag) {
|
||||
if (mag[3] > mag[2]/3) return 1;
|
||||
if (mag[10] > mag[9]/3) return 1;
|
||||
if (mag[6] > mag[7]/3) return -1;
|
||||
if (mag[-1] > mag[1]/3) return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// This function does not really correct the phase of the message, it just
|
||||
// applies a transformation to the first sample representing a given bit:
|
||||
//
|
||||
// If the previous bit was one, we amplify it a bit.
|
||||
// If the previous bit was zero, we decrease it a bit.
|
||||
//
|
||||
// This simple transformation makes the message a bit more likely to be
|
||||
// correctly decoded for out of phase messages:
|
||||
//
|
||||
// When messages are out of phase there is more uncertainty in sequences of the
|
||||
// same bit multiple times, since 11111 will be transmitted as continuously
|
||||
// altering magnitude (high, low, high, low...)
|
||||
//
|
||||
// However because the message is out of phase some part of the high is mixed
|
||||
// in the low part, so that it is hard to distinguish if it is a zero or a one.
|
||||
//
|
||||
// However when the message is out of phase passing from 0 to 1 or from 1 to 0
|
||||
// happens in a very recognizable way, for instance in the 0 -> 1 transition,
|
||||
// magnitude goes low, high, high, low, and one of of the two middle samples
|
||||
// the high will be *very* high as part of the previous or next high signal
|
||||
// will be mixed there.
|
||||
//
|
||||
// Applying our simple transformation we make more likely if the current bit is
|
||||
// a zero, to detect another zero. Symmetrically if it is a one it will be more
|
||||
// likely to detect a one because of the transformation. In this way similar
|
||||
// levels will be interpreted more likely in the correct way.
|
||||
void apply_phase_correction(uint16_t *mag) {
|
||||
int j;
|
||||
|
||||
mag += 16; // Skip preamble.
|
||||
for (j = 0; j < (MODE_S_LONG_MSG_BITS-1)*2; j += 2) {
|
||||
if (mag[j] > mag[j+1]) {
|
||||
// One
|
||||
mag[j+2] = (mag[j+2] * 5) / 4;
|
||||
} else {
|
||||
// Zero
|
||||
mag[j+2] = (mag[j+2] * 4) / 5;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Detect a Mode S messages inside the magnitude buffer pointed by 'mag' and of
|
||||
// size 'maglen' bytes. Every detected Mode S message is convert it into a
|
||||
// stream of bits and passed to the function to display it.
|
||||
void mode_s_detect(mode_s_t *self, uint16_t *mag, uint32_t maglen, mode_s_callback_t cb) {
|
||||
unsigned char bits[MODE_S_LONG_MSG_BITS];
|
||||
unsigned char msg[MODE_S_LONG_MSG_BITS/2];
|
||||
uint16_t aux[MODE_S_LONG_MSG_BITS*2];
|
||||
uint32_t j;
|
||||
int use_correction = 0;
|
||||
|
||||
// The Mode S preamble is made of impulses of 0.5 microseconds at the
|
||||
// following time offsets:
|
||||
//
|
||||
// 0 - 0.5 usec: first impulse.
|
||||
// 1.0 - 1.5 usec: second impulse.
|
||||
// 3.5 - 4 usec: third impulse.
|
||||
// 4.5 - 5 usec: last impulse.
|
||||
//
|
||||
// Since we are sampling at 2 Mhz every sample in our magnitude vector is
|
||||
// 0.5 usec, so the preamble will look like this, assuming there is an
|
||||
// impulse at offset 0 in the array:
|
||||
//
|
||||
// 0 -----------------
|
||||
// 1 -
|
||||
// 2 ------------------
|
||||
// 3 --
|
||||
// 4 -
|
||||
// 5 --
|
||||
// 6 -
|
||||
// 7 ------------------
|
||||
// 8 --
|
||||
// 9 -------------------
|
||||
for (j = 0; j < maglen - MODE_S_FULL_LEN*2; j++) {
|
||||
int low, high, delta, i, errors;
|
||||
int good_message = 0;
|
||||
|
||||
if (use_correction) goto good_preamble; // We already checked it.
|
||||
|
||||
// First check of relations between the first 10 samples representing a
|
||||
// valid preamble. We don't even investigate further if this simple
|
||||
// test is not passed.
|
||||
if (!(mag[j] > mag[j+1] &&
|
||||
mag[j+1] < mag[j+2] &&
|
||||
mag[j+2] > mag[j+3] &&
|
||||
mag[j+3] < mag[j] &&
|
||||
mag[j+4] < mag[j] &&
|
||||
mag[j+5] < mag[j] &&
|
||||
mag[j+6] < mag[j] &&
|
||||
mag[j+7] > mag[j+8] &&
|
||||
mag[j+8] < mag[j+9] &&
|
||||
mag[j+9] > mag[j+6]))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// The samples between the two spikes must be < than the average of the
|
||||
// high spikes level. We don't test bits too near to the high levels as
|
||||
// signals can be out of phase so part of the energy can be in the near
|
||||
// samples.
|
||||
high = (mag[j]+mag[j+2]+mag[j+7]+mag[j+9])/6;
|
||||
if (mag[j+4] >= high ||
|
||||
mag[j+5] >= high)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// Similarly samples in the range 11-14 must be low, as it is the space
|
||||
// between the preamble and real data. Again we don't test bits too
|
||||
// near to high levels, see above.
|
||||
if (mag[j+11] >= high ||
|
||||
mag[j+12] >= high ||
|
||||
mag[j+13] >= high ||
|
||||
mag[j+14] >= high)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
good_preamble:
|
||||
// If the previous attempt with this message failed, retry using
|
||||
// magnitude correction.
|
||||
if (use_correction) {
|
||||
memcpy(aux, mag+j+MODE_S_PREAMBLE_US*2, sizeof(aux));
|
||||
if (j && detect_out_of_phase(mag+j)) {
|
||||
apply_phase_correction(mag+j);
|
||||
}
|
||||
// TODO ... apply other kind of corrections.
|
||||
}
|
||||
|
||||
// Decode all the next 112 bits, regardless of the actual message size.
|
||||
// We'll check the actual message type later.
|
||||
errors = 0;
|
||||
for (i = 0; i < MODE_S_LONG_MSG_BITS*2; i += 2) {
|
||||
low = mag[j+i+MODE_S_PREAMBLE_US*2];
|
||||
high = mag[j+i+MODE_S_PREAMBLE_US*2+1];
|
||||
delta = low-high;
|
||||
if (delta < 0) delta = -delta;
|
||||
|
||||
if (i > 0 && delta < 256) {
|
||||
bits[i/2] = bits[i/2-1];
|
||||
} else if (low == high) {
|
||||
// Checking if two adiacent samples have the same magnitude is
|
||||
// an effective way to detect if it's just random noise that
|
||||
// was detected as a valid preamble.
|
||||
bits[i/2] = 2; // error
|
||||
if (i < MODE_S_SHORT_MSG_BITS*2) errors++;
|
||||
} else if (low > high) {
|
||||
bits[i/2] = 1;
|
||||
} else {
|
||||
// (low < high) for exclusion
|
||||
bits[i/2] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Restore the original message if we used magnitude correction.
|
||||
if (use_correction)
|
||||
memcpy(mag+j+MODE_S_PREAMBLE_US*2, aux, sizeof(aux));
|
||||
|
||||
// Pack bits into bytes
|
||||
for (i = 0; i < MODE_S_LONG_MSG_BITS; i += 8) {
|
||||
msg[i/8] =
|
||||
bits[i]<<7 |
|
||||
bits[i+1]<<6 |
|
||||
bits[i+2]<<5 |
|
||||
bits[i+3]<<4 |
|
||||
bits[i+4]<<3 |
|
||||
bits[i+5]<<2 |
|
||||
bits[i+6]<<1 |
|
||||
bits[i+7];
|
||||
}
|
||||
|
||||
int msgtype = msg[0]>>3;
|
||||
int msglen = mode_s_msg_len_by_type(msgtype)/8;
|
||||
|
||||
// Last check, high and low bits are different enough in magnitude to
|
||||
// mark this as real message and not just noise?
|
||||
delta = 0;
|
||||
for (i = 0; i < msglen*8*2; i += 2) {
|
||||
delta += abs(mag[j+i+MODE_S_PREAMBLE_US*2]-
|
||||
mag[j+i+MODE_S_PREAMBLE_US*2+1]);
|
||||
}
|
||||
delta /= msglen*4;
|
||||
|
||||
// Filter for an average delta of three is small enough to let almost
|
||||
// every kind of message to pass, but high enough to filter some random
|
||||
// noise.
|
||||
if (delta < 10*255) {
|
||||
use_correction = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
// If we reached this point, and error is zero, we are very likely with
|
||||
// a Mode S message in our hands, but it may still be broken and CRC
|
||||
// may not be correct. This is handled by the next layer.
|
||||
if (errors == 0 || (self->aggressive && errors < 3)) {
|
||||
struct mode_s_msg mm;
|
||||
|
||||
// Decode the received message
|
||||
mode_s_decode(self, &mm, msg);
|
||||
|
||||
// Skip this message if we are sure it's fine.
|
||||
if (mm.crcok) {
|
||||
j += (MODE_S_PREAMBLE_US+(msglen*8))*2;
|
||||
good_message = 1;
|
||||
if (use_correction)
|
||||
mm.phase_corrected = 1;
|
||||
}
|
||||
|
||||
// Pass data to the next layer
|
||||
if (self->check_crc == 0 || mm.crcok) {
|
||||
cb(self, &mm);
|
||||
}
|
||||
}
|
||||
|
||||
// Retry with phase correction if possible.
|
||||
if (!good_message && !use_correction) {
|
||||
j--;
|
||||
use_correction = 1;
|
||||
} else {
|
||||
use_correction = 0;
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,88 @@
|
|||
#ifndef __MODE_S_DECODER_H
|
||||
#define __MODE_S_DECODER_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include <math.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#define MODE_S_ICAO_CACHE_LEN 1024 // Power of two required
|
||||
#define MODE_S_LONG_MSG_BYTES (112/8)
|
||||
#define MODE_S_UNIT_FEET 0
|
||||
#define MODE_S_UNIT_METERS 1
|
||||
|
||||
// Program state
|
||||
typedef struct {
|
||||
// Internal state
|
||||
uint32_t icao_cache[sizeof(uint32_t)*MODE_S_ICAO_CACHE_LEN*2]; // Recently seen ICAO addresses cache
|
||||
|
||||
// Configuration
|
||||
int fix_errors; // Single bit error correction if true
|
||||
int aggressive; // Aggressive detection algorithm
|
||||
int check_crc; // Only display messages with good CRC
|
||||
} mode_s_t;
|
||||
|
||||
// The struct we use to store information about a decoded message
|
||||
struct mode_s_msg {
|
||||
// Generic fields
|
||||
unsigned char msg[MODE_S_LONG_MSG_BYTES]; // Binary message
|
||||
int msgbits; // Number of bits in message
|
||||
int msgtype; // Downlink format #
|
||||
int crcok; // True if CRC was valid
|
||||
uint32_t crc; // Message CRC
|
||||
int errorbit; // Bit corrected. -1 if no bit corrected.
|
||||
int aa1, aa2, aa3; // ICAO Address bytes 1 2 and 3
|
||||
int phase_corrected; // True if phase correction was applied.
|
||||
|
||||
// DF 11
|
||||
int ca; // Responder capabilities.
|
||||
|
||||
// DF 17
|
||||
int metype; // Extended squitter message type.
|
||||
int mesub; // Extended squitter message subtype.
|
||||
int heading_is_valid;
|
||||
int heading;
|
||||
int aircraft_type;
|
||||
int fflag; // 1 = Odd, 0 = Even CPR message.
|
||||
int tflag; // UTC synchronized?
|
||||
int raw_latitude; // Non decoded latitude
|
||||
int raw_longitude; // Non decoded longitude
|
||||
char flight[9]; // 8 chars flight number.
|
||||
int ew_dir; // 0 = East, 1 = West.
|
||||
int ew_velocity; // E/W velocity.
|
||||
int ns_dir; // 0 = North, 1 = South.
|
||||
int ns_velocity; // N/S velocity.
|
||||
int vert_rate_source; // Vertical rate source.
|
||||
int vert_rate_sign; // Vertical rate sign.
|
||||
int vert_rate; // Vertical rate.
|
||||
int velocity; // Computed from EW and NS velocity.
|
||||
|
||||
// DF4, DF5, DF20, DF21
|
||||
int fs; // Flight status for DF4,5,20,21
|
||||
int dr; // Request extraction of downlink request.
|
||||
int um; // Request extraction of downlink request.
|
||||
int identity; // 13 bits identity (Squawk).
|
||||
|
||||
// Fields used by multiple message types.
|
||||
int altitude, unit;
|
||||
};
|
||||
|
||||
typedef void (*mode_s_callback_t)(mode_s_t *self, struct mode_s_msg *mm);
|
||||
|
||||
void mode_s_init(mode_s_t *self);
|
||||
void mode_s_compute_magnitude_vector(short *data, uint16_t *mag, uint32_t size);
|
||||
void mode_s_detect(mode_s_t *self, uint16_t *mag, uint32_t maglen, mode_s_callback_t);
|
||||
void mode_s_decode(mode_s_t *self, struct mode_s_msg *mm, unsigned char *msg);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
|
@ -49,6 +49,7 @@
|
|||
#include <linux/semaphore.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/kfifo.h>
|
||||
|
||||
#define BCM2835_SMI_IMPLEMENTATION
|
||||
#include <linux/broadcom/bcm2835_smi.h>
|
||||
|
@ -228,10 +229,10 @@ void bcm2835_smi_set_regs_from_settings(struct bcm2835_smi_instance *inst)
|
|||
|
||||
// Additions (DM) <..
|
||||
|
||||
smics_temp |= SMICS_INTR; // Generate interrupt while RXR = 1
|
||||
//smics_temp |= SMICS_INTR; // Generate interrupt while RXR = 1
|
||||
// RXR = 1: RX FIFO is at least ¾ full or the transfer has finished and the
|
||||
// FIFO still needs reading. The transfer direction must be set to READ
|
||||
smics_temp |= SMICS_INTT; // Generate interrupt while TXW = 1
|
||||
//smics_temp |= SMICS_INTT; // Generate interrupt while TXW = 1
|
||||
// TXW = 1: TX FIFO is less than ¼ full and the transfer direction is set to WRITE.
|
||||
|
||||
// ..> Additions (DM)
|
||||
|
@ -690,6 +691,50 @@ static void smi_dma_write_sgl(
|
|||
}
|
||||
}
|
||||
|
||||
ssize_t bcm2835_smi_user_dma_read_to_fifo(
|
||||
struct bcm2835_smi_instance *inst,
|
||||
struct kfifo *fifo,
|
||||
size_t fifo_len)
|
||||
{
|
||||
struct dma_async_tx_descriptor *desc;
|
||||
struct scatterlist sg[2];
|
||||
unsigned int ret;
|
||||
size_t n_bytes;
|
||||
|
||||
ret = kfifo_dma_in_prepare(fifo, sg, ARRAY_SIZE(sg), fifo_len);
|
||||
|
||||
if (ret <= 0)
|
||||
{
|
||||
// no space in fifo, return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
n_bytes = sg[0].length + sg[1].length;
|
||||
smi_disable(inst, DMA_DEV_TO_MEM);
|
||||
desc = smi_dma_submit_sgl(inst, sg, ret, DMA_DEV_TO_MEM, NULL);
|
||||
|
||||
dma_async_issue_pending(inst->dma_chan);
|
||||
if (inst->settings.data_width == SMI_WIDTH_8BIT)
|
||||
{
|
||||
smi_init_programmed_read(inst, n_bytes);
|
||||
}
|
||||
else
|
||||
{
|
||||
smi_init_programmed_read(inst, n_bytes / 2);
|
||||
}
|
||||
|
||||
/*if (dma_wait_for_async_tx(desc) == DMA_ERROR)
|
||||
{
|
||||
smi_dump_context_labelled(inst, "DMA timeout!");
|
||||
return 0;
|
||||
}*/
|
||||
|
||||
kfifo_dma_in_finish(fifo, n_bytes);
|
||||
|
||||
return n_bytes;
|
||||
}
|
||||
EXPORT_SYMBOL(bcm2835_smi_user_dma_read_to_fifo);
|
||||
|
||||
ssize_t bcm2835_smi_user_dma(
|
||||
struct bcm2835_smi_instance *inst,
|
||||
enum dma_transfer_direction dma_dir,
|
||||
|
|
|
@ -184,6 +184,11 @@ static long smi_stream_ioctl(struct file *file, unsigned int cmd, unsigned long
|
|||
return ret;
|
||||
}
|
||||
|
||||
ssize_t bcm2835_smi_user_dma_read_to_fifo(
|
||||
struct bcm2835_smi_instance *inst,
|
||||
struct kfifo *fifo,
|
||||
size_t fifo_len);
|
||||
|
||||
int reader_thread_stream_function(void *pv)
|
||||
{
|
||||
struct bcm2835_smi_bounce_info *bounce = NULL;
|
||||
|
@ -198,6 +203,12 @@ int reader_thread_stream_function(void *pv)
|
|||
continue;
|
||||
}
|
||||
|
||||
/*count = bcm2835_smi_user_dma_read_to_fifo(smi_inst, &inst->rx_fifo, FIFO_SIZE_MULTIPLIER * DMA_BOUNCE_BUFFER_SIZE);
|
||||
if (count)
|
||||
{
|
||||
wake_up_interruptible(&inst->readable);
|
||||
}*/
|
||||
|
||||
count = bcm2835_smi_user_dma(smi_inst, DMA_DEV_TO_MEM, inst->rx_buffer,
|
||||
DMA_BOUNCE_BUFFER_SIZE, &bounce);
|
||||
//printk("count1 = %d\n", count);
|
||||
|
@ -211,7 +222,7 @@ int reader_thread_stream_function(void *pv)
|
|||
}
|
||||
|
||||
//count = 0;//dma_bounce_user(DMA_DEV_TO_MEM, inst->rx_buffer, DMA_BOUNCE_BUFFER_SIZE, bounce);
|
||||
/* Wait for current chunk to complete: */
|
||||
// Wait for current chunk to complete:
|
||||
if (down_timeout(&bounce->callback_sem, msecs_to_jiffies(1000)))
|
||||
{
|
||||
printk("DMA bounce timed out");
|
||||
|
|
|
@ -259,7 +259,7 @@ int cariboulite_set_rx_bandwidth(cariboulite_radios_st* radios,
|
|||
at86rf215_radio_f_cut_en fcut = at86rf215_radio_rx_f_cut_half_fs;
|
||||
|
||||
// Automatically calculate the digital f_cut
|
||||
/*if (rx_bw >= at86rf215_radio_rx_bw_BW160KHZ_IF250KHZ && rx_bw <= at86rf215_radio_rx_bw_BW500KHZ_IF500KHZ)
|
||||
if (rx_bw >= at86rf215_radio_rx_bw_BW160KHZ_IF250KHZ && rx_bw <= at86rf215_radio_rx_bw_BW500KHZ_IF500KHZ)
|
||||
fcut = at86rf215_radio_rx_f_cut_0_25_half_fs;
|
||||
else if (rx_bw >= at86rf215_radio_rx_bw_BW630KHZ_IF1000KHZ && rx_bw <= at86rf215_radio_rx_bw_BW630KHZ_IF1000KHZ)
|
||||
fcut = at86rf215_radio_rx_f_cut_0_375_half_fs;
|
||||
|
@ -268,7 +268,7 @@ int cariboulite_set_rx_bandwidth(cariboulite_radios_st* radios,
|
|||
else if (rx_bw >= at86rf215_radio_rx_bw_BW1250KHZ_IF2000KHZ && rx_bw <= at86rf215_radio_rx_bw_BW1250KHZ_IF2000KHZ)
|
||||
fcut = at86rf215_radio_rx_f_cut_0_75_half_fs;
|
||||
else
|
||||
fcut = at86rf215_radio_rx_f_cut_half_fs;*/
|
||||
fcut = at86rf215_radio_rx_f_cut_half_fs;
|
||||
|
||||
rad->rx_fcut = fcut;
|
||||
|
||||
|
@ -643,8 +643,10 @@ int cariboulite_set_frequency( cariboulite_radios_st* radios,
|
|||
double f_rf_mod_26 = (f_rf / 26e6);
|
||||
f_rf_mod_32 -= (uint64_t)(f_rf_mod_32);
|
||||
f_rf_mod_26 -= (uint64_t)(f_rf_mod_26);
|
||||
f_rf_mod_32 *= 32e6;
|
||||
f_rf_mod_26 *= 26e6;
|
||||
if (f_rf_mod_32 > 16e6) f_rf_mod_32 = 32e6 - f_rf_mod_32;
|
||||
if (f_rf_mod_26 > 13e6) f_rf_mod_26 = 13e6 - f_rf_mod_26;
|
||||
if (f_rf_mod_26 > 13e6) f_rf_mod_26 = 26e6 - f_rf_mod_26;
|
||||
ext_ref_choice = f_rf_mod_32 > f_rf_mod_26 ? cariboulite_ext_ref_32mhz : cariboulite_ext_ref_26mhz;
|
||||
cariboulite_setup_ext_ref (rad->cariboulite_sys, ext_ref_choice);
|
||||
|
||||
|
@ -668,9 +670,10 @@ int cariboulite_set_frequency( cariboulite_radios_st* radios,
|
|||
conversion_direction = conversion_dir_up;
|
||||
}
|
||||
//-------------------------------------
|
||||
else if ( f_rf >= CARIBOULITE_2G4_MIN &&
|
||||
else if ( f_rf > CARIBOULITE_2G4_MIN &&
|
||||
f_rf <= CARIBOULITE_2G4_MAX )
|
||||
{
|
||||
cariboulite_setup_ext_ref (rad->cariboulite_sys, cariboulite_ext_ref_off);
|
||||
// region #2 - bypass mode
|
||||
// setup modem frequency <= f_rf
|
||||
modem_act_freq = (double)at86rf215_setup_channel (&rad->cariboulite_sys->modem,
|
||||
|
|
|
@ -280,17 +280,17 @@ int cariboulite_setup_ext_ref ( cariboulite_st *sys, cariboulite_ext_ref_freq_en
|
|||
{
|
||||
case cariboulite_ext_ref_26mhz:
|
||||
ZF_LOGD("Setting ext_ref = 26MHz");
|
||||
at86rf215_set_clock_output(&sys->modem, at86rf215_drive_current_4ma, at86rf215_clock_out_freq_26mhz);
|
||||
at86rf215_set_clock_output(&sys->modem, at86rf215_drive_current_2ma, at86rf215_clock_out_freq_26mhz);
|
||||
rffc507x_setup_reference_freq(&sys->mixer, 26e6);
|
||||
break;
|
||||
case cariboulite_ext_ref_32mhz:
|
||||
ZF_LOGD("Setting ext_ref = 32MHz");
|
||||
at86rf215_set_clock_output(&sys->modem, at86rf215_drive_current_4ma, at86rf215_clock_out_freq_32mhz);
|
||||
at86rf215_set_clock_output(&sys->modem, at86rf215_drive_current_2ma, at86rf215_clock_out_freq_32mhz);
|
||||
rffc507x_setup_reference_freq(&sys->mixer, 32e6);
|
||||
break;
|
||||
case cariboulite_ext_ref_off:
|
||||
ZF_LOGD("Setting ext_ref = OFF");
|
||||
at86rf215_set_clock_output(&sys->modem, at86rf215_drive_current_4ma, at86rf215_clock_out_freq_off);
|
||||
at86rf215_set_clock_output(&sys->modem, at86rf215_drive_current_2ma, at86rf215_clock_out_freq_off);
|
||||
default:
|
||||
return -1;
|
||||
break;
|
||||
|
@ -355,7 +355,7 @@ int cariboulite_init_submodules (cariboulite_st* sys)
|
|||
|
||||
at86rf215_iq_interface_config_st modem_iq_config = {
|
||||
.loopback_enable = 0,
|
||||
.drv_strength = at86rf215_iq_drive_current_4ma,
|
||||
.drv_strength = at86rf215_iq_drive_current_2ma,
|
||||
.common_mode_voltage = at86rf215_iq_common_mode_v_ieee1596_1v2,
|
||||
.tx_control_with_iq_if = false,
|
||||
.radio09_mode = at86rf215_iq_if_mode,
|
||||
|
|
|
@ -8746,7 +8746,7 @@ void gpioTerminate(void)
|
|||
{
|
||||
int i;
|
||||
|
||||
printf("gpioTerminate\n");
|
||||
//printf("gpioTerminate\n");
|
||||
DBG(DBG_USER, "");
|
||||
|
||||
if (!libInitialised) return;
|
||||
|
@ -8765,7 +8765,7 @@ void gpioTerminate(void)
|
|||
initKillDMA(dmaOut);
|
||||
}
|
||||
|
||||
printf("gpioTerminate - reset DMA\n");
|
||||
//printf("gpioTerminate - reset DMA\n");
|
||||
|
||||
#ifndef EMBEDDED_IN_VM
|
||||
if ((gpioCfg.internals & PI_CFG_STATS) &&
|
||||
|
@ -8804,12 +8804,12 @@ void gpioTerminate(void)
|
|||
}
|
||||
|
||||
#endif
|
||||
printf("gpioTerminate - initReleaseResources\n");
|
||||
//printf("gpioTerminate - initReleaseResources\n");
|
||||
initReleaseResources();
|
||||
printf("gpioTerminate - initReleaseResources finished\n");
|
||||
//printf("gpioTerminate - initReleaseResources finished\n");
|
||||
fflush(NULL);
|
||||
|
||||
printf("gpioTerminate - finished FFlush\n");
|
||||
//printf("gpioTerminate - finished FFlush\n");
|
||||
libInitialised = 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -149,8 +149,8 @@ int rffc507x_init( rffc507x_st* dev,
|
|||
set_RFFC507X_P2CTV(dev, 12);
|
||||
set_RFFC507X_P1CTV(dev, 12);
|
||||
set_RFFC507X_RGBYP(dev, 1);
|
||||
set_RFFC507X_P2MIXIDD(dev, 2);
|
||||
set_RFFC507X_P1MIXIDD(dev, 2);
|
||||
set_RFFC507X_P2MIXIDD(dev, 6);
|
||||
set_RFFC507X_P1MIXIDD(dev, 6);
|
||||
|
||||
// Others
|
||||
set_RFFC507X_LDEN(dev, 1);
|
||||
|
|
|
@ -25,7 +25,7 @@ Cariboulite::Cariboulite(const SoapySDR::Kwargs &args)
|
|||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
int stream_id = CARIBOU_SMI_GET_STREAM_ID(types[i], channels[i]);
|
||||
sample_queues[i] = new SampleQueue(1024*1024/2, NUM_SAMPLEQUEUE_BUFS);
|
||||
sample_queues[i] = new SampleQueue(getStreamMTU(NULL)*NUM_BYTES_PER_CPLX_ELEM, NUM_SAMPLEQUEUE_BUFS);
|
||||
int dir = (types[i] == caribou_smi_stream_type_write)? SOAPY_SDR_TX : SOAPY_SDR_RX;
|
||||
int ch = (channels[i] == caribou_smi_channel_900)? cariboulite_channel_s1g : cariboulite_channel_6g;
|
||||
sample_queues[i]->AttachStreamId(stream_id, dir, ch);
|
||||
|
@ -33,7 +33,7 @@ Cariboulite::Cariboulite(const SoapySDR::Kwargs &args)
|
|||
|
||||
cariboulite_init_radios(&radios, &sess.cariboulite_sys);
|
||||
|
||||
SoapySDR_logf(SOAPY_SDR_INFO, "Cariboulite c'tor");
|
||||
//SoapySDR_logf(SOAPY_SDR_INFO, "Cariboulite c'tor");
|
||||
|
||||
// TODO: Exception when error
|
||||
}
|
||||
|
@ -47,7 +47,7 @@ Cariboulite::~Cariboulite()
|
|||
{
|
||||
delete sample_queues[i];
|
||||
}
|
||||
SoapySDR_logf(SOAPY_SDR_INFO, "Cariboulite d'tor");
|
||||
//SoapySDR_logf(SOAPY_SDR_INFO, "Cariboulite d'tor");
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
|
|
|
@ -30,7 +30,7 @@ enum Cariboulite_Format
|
|||
};
|
||||
|
||||
//#define BUFFER_SIZE_MS ( 10 )
|
||||
#define NUM_SAMPLEQUEUE_BUFS ( 10 )
|
||||
#define NUM_SAMPLEQUEUE_BUFS ( 3 )
|
||||
#define NUM_BYTES_PER_CPLX_ELEM ( 4 )
|
||||
//#define GET_MTU_MS(ms) ( 4000*(ms) )
|
||||
//#define GET_MTU_MS_BYTES(ms) ( GET_MTU_MS(ms) * NUM_BYTES_PER_CPLX_ELEM )
|
||||
|
|
|
@ -47,7 +47,7 @@ SampleQueue::SampleQueue(int mtu_bytes, int num_buffers)
|
|||
SampleQueue::~SampleQueue()
|
||||
{
|
||||
//printf("~SampleQueue streamID: %d, dir: %d, channel: %d\n", stream_id, stream_dir, stream_channel);
|
||||
SoapySDR_logf(SOAPY_SDR_INFO, "~SampleQueue streamID: %d, dir: %d, channel: %d", stream_id, stream_dir, stream_channel);
|
||||
//SoapySDR_logf(SOAPY_SDR_INFO, "~SampleQueue streamID: %d, dir: %d, channel: %d", stream_id, stream_dir, stream_channel);
|
||||
|
||||
stream_id = -1;
|
||||
stream_dir = -1;
|
||||
|
|
|
@ -64,11 +64,11 @@ SoapyCaribouliteSession::~SoapyCaribouliteSession(void)
|
|||
{
|
||||
std::lock_guard<std::mutex> lock(sessionMutex);
|
||||
//printf("~SoapyCaribouliteSession, sessionCount: %ld\n", sessionCount);
|
||||
SoapySDR_logf(SOAPY_SDR_INFO, "~SoapyCaribouliteSession, sessionCount: %ld", sessionCount);
|
||||
//SoapySDR_logf(SOAPY_SDR_INFO, "~SoapyCaribouliteSession, sessionCount: %ld", sessionCount);
|
||||
sessionCount--;
|
||||
if (sessionCount == 0)
|
||||
{
|
||||
cariboulite_release_driver(&cariboulite_sys);
|
||||
}
|
||||
SoapySDR_logf(SOAPY_SDR_INFO, "~SoapyCaribouliteSession CaribouLite released");
|
||||
//SoapySDR_logf(SOAPY_SDR_INFO, "~SoapyCaribouliteSession CaribouLite released");
|
||||
}
|
||||
|
|
|
@ -246,8 +246,8 @@ SoapySDR::Stream *Cariboulite::setupStream(const int direction,
|
|||
}
|
||||
}
|
||||
|
||||
SoapySDR_logf(SOAPY_SDR_INFO, "finished setup stream, stream_id = %d, CW=%d", stream_id, cw);
|
||||
return (SoapySDR::Stream *)((void*)stream_id);
|
||||
//SoapySDR_logf(SOAPY_SDR_INFO, "finished setup stream, stream_id = %d, CW=%d", stream_id, cw);
|
||||
return (SoapySDR::Stream *)((void*)(stream_id));
|
||||
}
|
||||
|
||||
//========================================================
|
||||
|
@ -258,7 +258,7 @@ SoapySDR::Stream *Cariboulite::setupStream(const int direction,
|
|||
*/
|
||||
void Cariboulite::closeStream(SoapySDR::Stream *stream)
|
||||
{
|
||||
SoapySDR_logf(SOAPY_SDR_INFO, "closeStream");
|
||||
//SoapySDR_logf(SOAPY_SDR_INFO, "closeStream");
|
||||
if (stream == NULL) return;
|
||||
int stream_id = (intptr_t)stream;
|
||||
|
||||
|
@ -278,7 +278,7 @@ void Cariboulite::closeStream(SoapySDR::Stream *stream)
|
|||
size_t Cariboulite::getStreamMTU(SoapySDR::Stream *stream) const
|
||||
{
|
||||
//printf("getStreamMTU\n");
|
||||
return 1024*1024/2; // # milliseconds of buffer
|
||||
return 1024 * 1024 / 2 / 4; // # milliseconds of buffer
|
||||
}
|
||||
|
||||
//========================================================
|
||||
|
@ -305,7 +305,7 @@ int Cariboulite::activateStream(SoapySDR::Stream *stream,
|
|||
const size_t numElems)
|
||||
{
|
||||
//printf("activateStream\n");
|
||||
SoapySDR_logf(SOAPY_SDR_INFO, "activateStream");
|
||||
//SoapySDR_logf(SOAPY_SDR_INFO, "activateStream");
|
||||
int stream_id = (intptr_t)stream;
|
||||
|
||||
cariboulite_activate_channel(&radios,
|
||||
|
@ -336,7 +336,7 @@ int Cariboulite::activateStream(SoapySDR::Stream *stream,
|
|||
*/
|
||||
int Cariboulite::deactivateStream(SoapySDR::Stream *stream, const int flags, const long long timeNs)
|
||||
{
|
||||
SoapySDR_logf(SOAPY_SDR_INFO, "deactivateStream");
|
||||
//SoapySDR_logf(SOAPY_SDR_INFO, "deactivateStream");
|
||||
int stream_id = (intptr_t)stream;
|
||||
|
||||
if ((cariboulite_channel_en)sample_queues[stream_id]->is_cw == 0)
|
||||
|
|
Ładowanie…
Reference in New Issue