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