1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/*
Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Her Majesty the
Queen in Right of Canada (Communications Research Center Canada)
Copyright (C) 2017
Matthias P. Braendli, matthias.braendli@mpb.li
http://opendigitalradio.org
DESCRIPTION:
Common interface for all SDR outputs
*/
/*
This file is part of ODR-DabMod.
ODR-DabMod is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
ODR-DabMod is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with ODR-DabMod. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "ModPlugin.h"
#include "EtiReader.h"
namespace Output {
using complexf = std::complex<float>;
enum refclk_lock_loss_behaviour_t { CRASH, IGNORE };
/* This structure is used as initial configuration for all SDR devices.
* It must also contain all remote-controllable settings, otherwise
* they will get lost on a modulator restart. */
struct SDRDeviceConfig {
std::string device;
std::string subDevice; // For UHD
long masterClockRate = 32768000;
unsigned sampleRate = 2048000;
double frequency = 0.0;
double lo_offset = 0.0;
double txgain = 0.0;
double rxgain = 0.0;
bool enableSync = false;
// When working with timestamps, mute the frames that
// do not have a timestamp
bool muteNoTimestamps = false;
unsigned dabMode = 0;
unsigned maxGPSHoldoverTime = 0;
/* allowed values for UHD : auto, int, sma, mimo */
std::string refclk_src;
/* allowed values for UHD : int, sma, mimo */
std::string pps_src;
/* allowed values for UHD : pos, neg */
std::string pps_polarity;
/* What to do when the reference clock PLL loses lock */
refclk_lock_loss_behaviour_t refclk_lock_loss_behaviour;
// muting can only be changed using the remote control
bool muting = false;
// TCP port on which to serve TX and RX samples for the
// digital pre distortion learning tool
uint16_t dpdFeedbackServerPort = 0;
};
// Each frame contains one OFDM frame, and its
// associated timestamp
struct FrameData {
// Buffer holding frame data
std::vector<uint8_t> buf;
// A full timestamp contains a TIST according to standard
// and time information within MNSC with tx_second.
struct frame_timestamp ts;
};
// All SDR Devices must implement the SDRDevice interface
class SDRDevice {
public:
struct RunStatistics {
size_t num_underruns;
size_t num_late_packets;
size_t num_overruns;
size_t num_frames_modulated; //TODO increment
};
// TODO make some functions const
virtual void tune(double lo_offset, double frequency) = 0;
virtual double get_tx_freq(void) = 0;
virtual void set_txgain(double txgain) = 0;
virtual double get_txgain(void) = 0;
virtual void transmit_frame(const struct FrameData& frame) = 0;
virtual RunStatistics get_run_statistics(void) = 0;
virtual double get_real_secs(void) = 0;
// Return true if GPS and reference clock inputs are ok
virtual bool is_clk_source_ok(void) = 0;
virtual const char* device_name(void) = 0;
};
class SDR : public ModOutput, public RemoteControllable {
public:
SDR(SDRDeviceConfig& config, std::shared_ptr<SDRDevice> device);
SDR(const SDR& other) = delete;
SDR operator=(const SDR& other) = delete;
~SDR();
virtual int process(Buffer *dataIn) override;
virtual const char* name() override;
void setETISource(EtiSource *etiSource);
/*********** REMOTE CONTROL ***************/
/* Base function to set parameters. */
virtual void set_parameter(const std::string& parameter,
const std::string& value) override;
/* Getting a parameter always returns a string. */
virtual const std::string get_parameter(
const std::string& parameter) const override;
private:
void stop(void);
void process_thread_entry(void);
void handle_frame(struct FrameData &frame);
SDRDeviceConfig& m_config;
std::atomic<bool> m_running;
std::thread m_device_thread;
ThreadsafeQueue<FrameData> m_queue;
std::shared_ptr<SDRDevice> m_device;
std::string m_name;
EtiSource *m_eti_source = nullptr;
bool sourceContainsTimestamp = false;
bool last_tx_time_initialised = false;
uint32_t last_tx_second = 0;
uint32_t last_tx_pps = 0;
};
}
|
