SDDC_Driver
Loading...
Searching...
No Matches
RadioHardware.h
1/*
2 * This file is part of SDDC_Driver.
3 *
4 * Copyright (C) 2020 - Howard Su
5 * Copyright (C) 2021 - Oscar Steila
6 * Copyright (C) 2025 - RenardSpark
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22#ifndef _H_RADIOHARDWARE
23#define _H_RADIOHARDWARE
24
25#include "../config.h"
26#include "../FX3Class.h"
27
28#include <vector>
29#include <array>
30
31using namespace std;
32
33class RadioHardware {
34 public:
35 RadioHardware(fx3class* fx3): Fx3(fx3) {}
36 virtual ~RadioHardware();
37
38 // ----- Common methods ----- //
39 sddc_rf_mode_t GetRFMode();
40 virtual sddc_rf_mode_t GetBestRFMode(uint64_t freq) = 0;
41 virtual sddc_err_t SetRFMode(sddc_rf_mode_t mode) = 0;
42
43 // --- ADC --- //
44 uint32_t GetADCSampleRate();
45 sddc_err_t SetADCSampleRate(uint32_t samplefreq);
46 virtual const array<float, 2> GetADCSampleRateLimits() = 0;
47
48 // --- Bias T --- //
49 bool GetBiasT_HF ();
50 sddc_err_t SetBiasT_HF (bool new_state);
51 bool GetBiasT_VHF();
52 sddc_err_t SetBiasT_VHF(bool new_state);
53
54 // --- Gain --- //
55 uint16_t GetRF_HF();
56 uint16_t GetRF_VHF();
57 uint16_t GetIF_HF();
58 uint16_t GetIF_VHF();
59
60 // --- Tuner --- //
61 uint32_t GetCenterFrequency_HF ();
62 uint32_t GetCenterFrequency_VHF();
63
64 // --- Misc --- //
65 bool GetDither();
66 sddc_err_t SetDither(bool new_state);
67 bool GetPGA ();
68 sddc_err_t SetPGA (bool new_state);
69 bool GetRand();
70 sddc_err_t SetRand(bool new_state);
71
72 // --- Data stream --- //
73 sddc_err_t StartStream() { return Fx3->Control(STARTFX3) ? ERR_SUCCESS : ERR_FX3_TRANSFER_FAILED; }
74 sddc_err_t StopStream () { return Fx3->Control(STOPFX3) ? ERR_SUCCESS : ERR_FX3_TRANSFER_FAILED; }
75
76 // --- GPIOs --- //
77 sddc_err_t SetGPIO (uint32_t mask);
78 sddc_err_t UnsetGPIO(uint32_t mask);
79 sddc_err_t SetLED (sddc_leds_t led, bool on);
80
81 bool ReadDebugTrace(uint8_t* pdata, uint8_t len) { return Fx3->ReadDebugTrace(pdata, len); }
82 // ----- //
83
84 // ----- Custom methods ----- //
85 virtual const char* GetName() = 0;
86 virtual float getGain() = 0;
87
88 // --- Tuner --- //
89 virtual sddc_err_t SetCenterFrequency_HF (uint32_t freq) = 0;
90 virtual sddc_err_t SetCenterFrequency_VHF(uint32_t freq) = 0;
91 virtual uint32_t GetTunerFrequency_HF() = 0;
92 virtual uint32_t GetTunerFrequency_VHF() = 0;
93
94 // --- RF settings --- //
95 virtual vector<float> GetRFSteps_HF () = 0;
96 virtual vector<float> GetRFSteps_VHF() = 0;
97 virtual sddc_err_t SetRFAttenuation_HF (size_t attIndex) = 0;
98 virtual sddc_err_t SetRFAttenuation_VHF(uint16_t attIndex) = 0;
99
100 // --- IF settings --- //
101 virtual vector<float> GetIFSteps_HF () = 0;
102 virtual vector<float> GetIFSteps_VHF() = 0;
103 virtual sddc_err_t SetIFGain_HF (size_t attIndex) = 0;
104 virtual sddc_err_t SetIFGain_VHF (size_t attIndex) = 0;
105
106
107 protected:
108 fx3class* Fx3;
109 uint32_t gpios = 0;
110
111 uint32_t sampleRate = 0;
112 sddc_rf_mode_t currentRFMode = NOMODE;
113
114 bool stateDither = false;
115 bool statePGA = false;
116 bool stateRand = false;
117 bool stateBiasT_HF = false;
118 bool stateBiasT_VHF = false;
119
120 uint16_t attenuationHFStep = 0;
121 uint16_t attenuationVHFStep = 0;
122 uint16_t gainHFStep = 0;
123 uint16_t gainVHFStep = 0;
124
125 uint32_t freqLO_HF = 0;
126 uint32_t freqLO_VHF = 0;
127};
128
129class BBRF103Radio : public RadioHardware {
130 public:
131 BBRF103Radio(fx3class* fx3);
132
133 const char* GetName() override { return "BBRF103"; }
134 float getGain() override { return BBRF103_GAINFACTOR; }
135
136 const array<float, 2> GetADCSampleRateLimits() override;
137
138 // --- Tuner --- //
139 sddc_err_t SetCenterFrequency_HF (uint32_t freq) override;
140 sddc_err_t SetCenterFrequency_VHF(uint32_t freq) override;
141 uint32_t GetTunerFrequency_HF() override;
142 uint32_t GetTunerFrequency_VHF() override;
143
144 // --- RF settings --- //
145 sddc_rf_mode_t GetBestRFMode(uint64_t freq) override;
146 sddc_err_t SetRFMode(sddc_rf_mode_t mode) override;
147 vector<float> GetRFSteps_HF () override;
148 vector<float> GetRFSteps_VHF() override;
149 sddc_err_t SetRFAttenuation_HF (size_t attIndex) override;
150 sddc_err_t SetRFAttenuation_VHF(uint16_t attIndex) override;
151
152 // --- IF settings --- //
153 vector<float> GetIFSteps_HF () override;
154 sddc_err_t SetIFGain_HF (size_t attIndex) override;
155 vector<float> GetIFSteps_VHF() override;
156 sddc_err_t SetIFGain_VHF (size_t attIndex) override;
157
158 private:
159 static const vector<float> rf_steps_vhf;
160 static const vector<float> rf_steps_hf;
161 static const vector<float> if_steps_vhf;
162};
163
164class RX888Radio : public BBRF103Radio {
165public:
166 RX888Radio(fx3class* fx3) : BBRF103Radio(fx3) {}
167 const char* GetName() override { return "RX888"; }
168 float getGain() override { return RX888_GAINFACTOR; }
169};
170
171class RX888R2Radio : public RadioHardware {
172 public:
173 RX888R2Radio(fx3class* fx3);
174 const char* GetName() override { return "RX888 mkII"; }
175 float getGain() override { return RX888mk2_GAINFACTOR; }
176
177 const array<float, 2> GetADCSampleRateLimits() override;
178
179 sddc_err_t SetCenterFrequency_HF (uint32_t freq) override;
180 sddc_err_t SetCenterFrequency_VHF(uint32_t freq) override;
181 uint32_t GetTunerFrequency_HF() override;
182 uint32_t GetTunerFrequency_VHF() override;
183
184 // --- RF settings --- //
185 sddc_rf_mode_t GetBestRFMode(uint64_t freq) override;
186 sddc_err_t SetRFMode(sddc_rf_mode_t mode) override;
187 vector<float> GetRFSteps_HF() override;
188 vector<float> GetRFSteps_VHF() override;
189 sddc_err_t SetRFAttenuation_HF(size_t attIndex) override;
190 sddc_err_t SetRFAttenuation_VHF(uint16_t attIndex) override;
191
192 // --- IF settings --- //
193 vector<float> GetIFSteps_HF () override;
194 vector<float> GetIFSteps_VHF() override;
195 sddc_err_t SetIFGain_HF (size_t attIndex) override;
196 sddc_err_t SetIFGain_VHF (size_t attIndex) override;
197
198 private:
199 vector<float> rf_steps_hf = vector<float>(64, 0);
200 vector<float> if_steps_hf = vector<float>(127, 0);
201 static const vector<float> rf_steps_vhf;
202 static const vector<float> if_steps_vhf;
203};
204
205class RX888R3Radio : public RadioHardware {
206 public:
207 RX888R3Radio(fx3class* fx3);
208 const char* GetName() override { return "RX888 mkIII"; }
209 float getGain() override { return RX888mk2_GAINFACTOR; }
210
211 const array<float, 2> GetADCSampleRateLimits() override;
212
213 // --- Tuner --- //
214 sddc_err_t SetCenterFrequency_HF (uint32_t freq) override;
215 sddc_err_t SetCenterFrequency_VHF(uint32_t freq) override;
216 uint32_t GetTunerFrequency_HF() override;
217 uint32_t GetTunerFrequency_VHF() override;
218
219 // --- RF settings --- //
220 sddc_rf_mode_t GetBestRFMode(uint64_t freq) override;
221 sddc_err_t SetRFMode(sddc_rf_mode_t mode) override;
222 vector<float> GetRFSteps_HF () override;
223 vector<float> GetRFSteps_VHF() override;
224 sddc_err_t SetRFAttenuation_HF (size_t attIndex) override;
225 sddc_err_t SetRFAttenuation_VHF(uint16_t attIndex) override;
226
227 // --- IF settings --- //
228 vector<float> GetIFSteps_HF () override;
229 sddc_err_t SetIFGain_HF (size_t attIndex) override;
230 vector<float> GetIFSteps_VHF() override;
231 sddc_err_t SetIFGain_VHF (size_t attIndex) override;
232
233 private:
234
235 vector<float> rf_steps_hf;
236 vector<float> if_steps_hf;
237 static const vector<float> rf_steps_vhf;
238 static const vector<float> if_steps_vhf;
239
240 uint32_t freqLO_VHF_offset = 0;
241};
242
243class RX999Radio : public RadioHardware {
244 public:
245 RX999Radio(fx3class* fx3);
246 const char* GetName() override { return "RX999"; }
247 float getGain() override { return RX888_GAINFACTOR; }
248
249 const array<float, 2> GetADCSampleRateLimits() override;
250
251 // --- Tuner --- //
252 sddc_err_t SetCenterFrequency_HF (uint32_t freq) override;
253 sddc_err_t SetCenterFrequency_VHF(uint32_t freq) override;
254 uint32_t GetTunerFrequency_HF() override;
255 uint32_t GetTunerFrequency_VHF() override;
256
257 // --- RF settings --- //
258 sddc_rf_mode_t GetBestRFMode(uint64_t freq) override;
259 sddc_err_t SetRFMode(sddc_rf_mode_t mode) override;
260 vector<float> GetRFSteps_HF () override;
261 vector<float> GetRFSteps_VHF() override;
262 sddc_err_t SetRFAttenuation_HF (size_t attIndex) override;
263 sddc_err_t SetRFAttenuation_VHF(uint16_t attIndex) override;
264
265 // --- IF settings --- //
266 vector<float> GetIFSteps_HF () override;
267 sddc_err_t SetIFGain_HF (size_t attIndex) override;
268 vector<float> GetIFSteps_VHF() override;
269 sddc_err_t SetIFGain_VHF (size_t attIndex) override;
270
271 private:
272 vector<float> if_steps_hf;
273};
274
275class HF103Radio : public RadioHardware {
276 public:
277 HF103Radio(fx3class* fx3);
278 const char* GetName() override { return "HF103"; }
279 float getGain() override { return HF103_GAINFACTOR; }
280
281 const array<float, 2> GetADCSampleRateLimits() override;
282
283 // --- Tuner --- //
284 sddc_err_t SetCenterFrequency_HF (uint32_t freq) override;
285 sddc_err_t SetCenterFrequency_VHF(uint32_t freq) override;
286 uint32_t GetTunerFrequency_HF() override;
287 uint32_t GetTunerFrequency_VHF() override;
288
289 // --- RF settings --- //
290 sddc_rf_mode_t GetBestRFMode(uint64_t freq) override;
291 sddc_err_t SetRFMode(sddc_rf_mode_t mode) override;
292 vector<float> GetRFSteps_HF () override;
293 vector<float> GetRFSteps_VHF() override;
294 sddc_err_t SetRFAttenuation_HF (size_t attIndex) override;
295 sddc_err_t SetRFAttenuation_VHF(uint16_t attIndex) override;
296
297 // --- IF settings --- //
298 vector<float> GetIFSteps_HF () override;
299 sddc_err_t SetIFGain_HF (size_t attIndex) override;
300 vector<float> GetIFSteps_VHF() override;
301 sddc_err_t SetIFGain_VHF (size_t attIndex) override;
302
303 private:
304 static const int step_size = 64;
305 vector<float> rf_steps_hf;
306};
307
308class RXLucyRadio : public RadioHardware {
309 public:
310 RXLucyRadio(fx3class* fx3);
311 const char* GetName() override { return "Lucy"; }
312 float getGain() override { return HF103_GAINFACTOR; }
313
314 const array<float, 2> GetADCSampleRateLimits() override;
315
316 // --- Tuner --- //
317 sddc_err_t SetCenterFrequency_HF (uint32_t freq) override;
318 sddc_err_t SetCenterFrequency_VHF(uint32_t freq) override;
319 uint32_t GetTunerFrequency_HF() override;
320 uint32_t GetTunerFrequency_VHF() override;
321
322 // --- RF settings --- //
323 sddc_rf_mode_t GetBestRFMode(uint64_t freq) override;
324 sddc_err_t SetRFMode(sddc_rf_mode_t mode) override;
325 vector<float> GetRFSteps_HF () override;
326 vector<float> GetRFSteps_VHF() override;
327 sddc_err_t SetRFAttenuation_HF (size_t attIndex) override;
328 sddc_err_t SetRFAttenuation_VHF(uint16_t attIndex) override;
329
330 // --- IF settings --- //
331 vector<float> GetIFSteps_HF () override;
332 sddc_err_t SetIFGain_HF (size_t attIndex) override;
333 vector<float> GetIFSteps_VHF() override;
334 sddc_err_t SetIFGain_VHF (size_t attIndex) override;
335
336 private:
337 vector<float> rf_steps_hf;
338 vector<float> if_steps_hf;
339};
340
341class DummyRadio : public RadioHardware {
342public:
343 DummyRadio(fx3class* fx3) : RadioHardware(fx3) {}
344 const char* GetName() override { return "Dummy"; }
345 float getGain() override { return 0; }
346
347 const array<float, 2> GetADCSampleRateLimits() override { return array<float, 2>{ 1000000, 64000000 }; };
348
349 sddc_rf_mode_t GetBestRFMode(uint64_t) override { return HFMODE; }
350 sddc_err_t SetRFMode(sddc_rf_mode_t) override { return ERR_SUCCESS; }
351
352 sddc_err_t SetCenterFrequency_HF (uint32_t) override { return ERR_SUCCESS; };
353 sddc_err_t SetCenterFrequency_VHF(uint32_t) override { return ERR_SUCCESS; };
354 uint32_t GetTunerFrequency_HF() override { return 0; };
355 uint32_t GetTunerFrequency_VHF() override { return 0; };
356
357 vector<float> GetRFSteps_HF () override { return vector<float>(); };
358 vector<float> GetRFSteps_VHF() override { return vector<float>(); };
359 sddc_err_t SetRFAttenuation_HF (size_t) override { return ERR_SUCCESS; };
360 sddc_err_t SetRFAttenuation_VHF(uint16_t) override { return ERR_SUCCESS; };
361
362 // --- IF settings --- //
363 vector<float> GetIFSteps_HF () override { return vector<float>(); };
364 sddc_err_t SetIFGain_HF (size_t) override { return ERR_SUCCESS; };
365 vector<float> GetIFSteps_VHF() override { return vector<float>(); };
366 sddc_err_t SetIFGain_VHF (size_t) override { return ERR_SUCCESS; };
367};
368
369#endif
BBRF103Radio
Definition RadioHardware.h:129
DummyRadio
Definition RadioHardware.h:341
HF103Radio
Definition RadioHardware.h:275
RX888R2Radio
Definition RadioHardware.h:171
RX888R3Radio
Definition RadioHardware.h:205
RX888Radio
Definition RadioHardware.h:164
RX999Radio
Definition RadioHardware.h:243
RXLucyRadio
Definition RadioHardware.h:308
RadioHardware
Definition RadioHardware.h:33
RadioHardware::SetLED
sddc_err_t SetLED(sddc_leds_t led, bool on)
Change the state of an LED.
Definition RadioHardware.cpp:197
fx3class
Definition FX3Class.h:24
Generated by doxygen 1.12.0