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
|
/*
Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Her Majesty the
Queen in Right of Canada (Communications Research Center Canada)
Copyright (C) 2023
Matthias P. Braendli, matthias.braendli@mpb.li
http://opendigitalradio.org
DESCRIPTION:
It is an output driver using libiio targeting the PrecisionWave DEXTER board.
*/
/*
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
#if defined(HAVE_DEXTER)
#if !defined(HAVE_ZEROMQ)
#error "ZeroMQ is mandatory for DEXTER"
#endif
#include "iio.h"
#include "zmq.hpp"
#include <string>
#include <memory>
#include <ctime>
#include <mutex>
#include <thread>
#include <variant>
#include "output/SDR.h"
#include "ModPlugin.h"
#include "EtiReader.h"
#include "RemoteControl.h"
namespace Output {
enum class DexterClockState {
Startup,
Normal,
Holdover
};
class Dexter : public Output::SDRDevice
{
public:
Dexter(SDRDeviceConfig& config);
Dexter(const Dexter& other) = delete;
Dexter& operator=(const Dexter& other) = delete;
virtual ~Dexter();
virtual void tune(double lo_offset, double frequency) override;
virtual double get_tx_freq(void) const override;
virtual void set_txgain(double txgain) override;
virtual double get_txgain() const override;
virtual void set_bandwidth(double bandwidth) override;
virtual double get_bandwidth() const override;
virtual void transmit_frame(struct FrameData&& frame) override;
virtual run_statistics_t get_run_statistics() const override;
virtual double get_real_secs() const override;
virtual void set_rxgain(double rxgain) override;
virtual double get_rxgain() const override;
virtual size_t receive_frame(
complexf *buf,
size_t num_samples,
frame_timestamp& ts,
double timeout_secs) override;
// Return true if GPS and reference clock inputs are ok
virtual bool is_clk_source_ok() override;
virtual const char* device_name() const override;
virtual std::optional<double> get_temperature() const override;
private:
void channel_up();
void channel_down();
void handle_hw_time();
bool m_channel_is_up = false;
SDRDeviceConfig& m_conf;
struct iio_context* m_ctx = nullptr;
struct iio_device* m_dexter_dsp_tx = nullptr;
struct iio_device* m_ad9957 = nullptr;
struct iio_device* m_ad9957_tx0 = nullptr;
struct iio_channel* m_tx_channel = nullptr;
struct iio_buffer *m_buffer = nullptr;
/* Underflows are counted in a separate thread */
struct iio_context* m_underflow_ctx = nullptr;
std::atomic<bool> m_running = ATOMIC_VAR_INIT(false);
std::thread m_underflow_read_thread;
void underflow_read_process();
mutable std::mutex m_attr_thread_mutex;
size_t underflows = 0;
size_t prev_underflows = 0;
size_t num_late = 0;
size_t num_frames_modulated = 0;
size_t num_buffers_pushed = 0;
/* Communication with pacontrol */
zmq::context_t m_zmq_context;
zmq::socket_t m_zmq_sock;
std::string m_pacontrol_endpoint;
/* Clock State */
DexterClockState m_clock_state = DexterClockState::Startup;
// Only valid when m_clock_state is not Startup
uint64_t m_utc_seconds_at_startup = 0;
uint64_t m_clock_count_at_startup = 0;
// Only valid when m_clock_state Holdover
std::chrono::steady_clock::time_point m_holdover_since =
std::chrono::steady_clock::time_point::min();
std::time_t m_holdover_since_t = 0;
};
} // namespace Output
#endif //HAVE_DEXTER
|
