diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2de515ce0..772b8c2cc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -383,6 +383,9 @@ if(ENABLE_HACKRF)
endif()
if(ENABLE_LIMESUITE)
find_package(LimeSuite)
+ if (LIMERFE_FOUND)
+ add_definitions(-DHAS_LIMERFE)
+ endif()
endif()
if(ENABLE_IIO) # PlutoSDR
find_package(LibIIO)
diff --git a/cmake/Modules/FindLimeSuite.cmake b/cmake/Modules/FindLimeSuite.cmake
index d7ea7f41e..a06335d4d 100644
--- a/cmake/Modules/FindLimeSuite.cmake
+++ b/cmake/Modules/FindLimeSuite.cmake
@@ -28,8 +28,19 @@ endif (LIMESUITE_INCLUDE_DIR AND LIMESUITE_LIBRARY)
if (LIMESUITE_FOUND)
message (STATUS "Found Lime Suite: ${LIMESUITE_INCLUDE_DIR}, ${LIMESUITE_LIBRARY}")
+ find_file(LIMERFE_INCLUDE_FILE
+ name lime/limeRFE.h
+ HINTS ${LIMESUITE_INCLUDE_DIR}
+ )
else (LIMESUITE_FOUND)
message (STATUS "Could not find Lime Suite")
endif (LIMESUITE_FOUND)
+if (LIMERFE_INCLUDE_FILE)
+ set(LIMERFE_FOUND TRUE)
+ message (STATUS "Lime Suite has LimeRFE support: ${LIMERFE_INCLUDE_FILE}")
+else()
+ message (STATUS "Lime Suite has not LimeRFE support")
+endif()
+
mark_as_advanced(LIMESUITE_INCLUDE_DIR LIMESUITE_LIBRARY)
diff --git a/sdrbase/CMakeLists.txt b/sdrbase/CMakeLists.txt
index c8c5eb02c..f61f87a54 100644
--- a/sdrbase/CMakeLists.txt
+++ b/sdrbase/CMakeLists.txt
@@ -31,6 +31,19 @@ else(FFTW3F_FOUND)
add_definitions(-DUSE_KISSFFT)
endif(FFTW3F_FOUND)
+if (LIMERFE_FOUND)
+ set(sdrbase_SOURCES
+ ${sdrbase_SOURCES}
+ limerfe/limerfecontroller.cpp
+ )
+ set(sdrbase_HEADERS
+ ${sdrbase_HEADERS}
+ limerfe/limerfecontroller.h
+ )
+ include_directories(${LIMESUITE_INCLUDE_DIR})
+ set(sdrbase_LIMERFE_LIB ${LIMESUITE_LIBRARY})
+endif (LIMERFE_FOUND)
+
# serialdv now required
add_definitions(-DDSD_USE_SERIALDV)
include_directories(${LIBSERIALDV_INCLUDE_DIR})
@@ -132,6 +145,7 @@ set(sdrbase_SOURCES
util/syncmessenger.cpp
util/samplesourceserializer.cpp
util/simpleserializer.cpp
+ util/serialutil.cpp
#util/spinlock.cpp
util/uid.cpp
util/timeutil.cpp
@@ -280,6 +294,7 @@ set(sdrbase_HEADERS
util/syncmessenger.h
util/samplesourceserializer.h
util/simpleserializer.h
+ util/serialutil.h
#util/spinlock.h
util/uid.h
util/timeutil.h
@@ -313,6 +328,7 @@ target_link_libraries(sdrbase
${OPUS_LIBRARIES}
${sdrbase_FFTW3F_LIB}
${sdrbase_SERIALDV_LIB}
+ ${sdrbase_LIMERFE_LIB}
Qt5::Core
Qt5::Multimedia
httpserver
diff --git a/sdrbase/limerfe/limerfecontroller.cpp b/sdrbase/limerfe/limerfecontroller.cpp
new file mode 100644
index 000000000..df67897b3
--- /dev/null
+++ b/sdrbase/limerfe/limerfecontroller.cpp
@@ -0,0 +1,531 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2020 Edouard Griffiths, F4EXB //
+// //
+// This program 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 as version 3 of the License, or //
+// (at your option) any later version. //
+// //
+// This program 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 V3 for more details. //
+// //
+// You should have received a copy of the GNU General Public License //
+// along with this program. If not, see . //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include
+
+#include "limerfecontroller.h"
+
+const std::map LimeRFEController::m_errorCodesMap = {
+ { 0, "OK"},
+ {-4, "Error synchronizing communication"},
+ {-3, "Non-configurable GPIO pin specified. Only pins 4 and 5 are configurable."},
+ {-2, "Problem with .ini configuration file"},
+ {-1, "Communication error"},
+ { 1, "Wrong TX connector - not possible to route TX of the selecrted channel to the specified port"},
+ { 2, "Wrong RX connector - not possible to route RX of the selecrted channel to the specified port"},
+ { 3, "Mode TXRX not allowed - when the same port is selected for RX and TX, it is not allowed to use mode RX & TX"},
+ { 4, "Wrong mode for cellular channel - Cellular FDD bands (1, 2, 3, and 7) are only allowed mode RX & TX, while TDD band 38 is allowed only RX or TX mode"},
+ { 5, "Cellular channels must be the same both for RX and TX"},
+ { 6, "Requested channel code is wrong"}
+};
+
+LimeRFEController::LimeRFESettings::LimeRFESettings()
+{
+ m_rxChannels = ChannelsWideband;
+ m_rxWidebandChannel = WidebandLow;
+ m_rxHAMChannel = HAM_144_146MHz;
+ m_rxCellularChannel = CellularBand38;
+ m_rxPort = RxPortJ3;
+ m_amfmNotch = false;
+ m_attenuationFactor = 0;
+ m_txChannels = ChannelsWideband;
+ m_txWidebandChannel = WidebandLow;
+ m_txHAMChannel = HAM_144_146MHz;
+ m_txCellularChannel = CellularBand38;
+ m_txPort = TxPortJ3;
+ m_txRxDriven = false;
+ m_rxOn = false;
+ m_txOn = false;
+}
+
+LimeRFEController::LimeRFEController() :
+ m_rfeDevice(nullptr)
+{}
+
+LimeRFEController::~LimeRFEController()
+{
+ if (m_rfeDevice) {
+ closeDevice();
+ }
+}
+
+int LimeRFEController::openDevice(const std::string& serialDeviceName)
+{
+ if (m_rfeDevice) {
+ closeDevice();
+ }
+
+ rfe_dev_t *rfeDevice = RFE_Open(serialDeviceName.c_str(), nullptr);
+
+ if (rfeDevice != (void *) -1) {
+ m_rfeDevice = rfeDevice;
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+void LimeRFEController::closeDevice()
+{
+ RFE_Close(m_rfeDevice);
+ m_rfeDevice = nullptr;
+}
+
+int LimeRFEController::configure()
+{
+ if (!m_rfeDevice) {
+ return -1;
+ }
+
+ int rc = RFE_ConfigureState(m_rfeDevice, m_rfeBoardState);
+
+ if (rc != 0) {
+ qInfo("LimeRFEController::configure: %s", getError(rc).c_str());
+ }
+
+ return rc;
+}
+
+int LimeRFEController::getState()
+{
+ if (!m_rfeDevice) {
+ return -1;
+ }
+
+ int rc = RFE_GetState(m_rfeDevice, &m_rfeBoardState);
+
+ qDebug() << "LimeRFEController::getState: "
+ << "attValue: " << (int) m_rfeBoardState.attValue
+ << "channelIDRX: " << (int) m_rfeBoardState.channelIDRX
+ << "channelIDTX: " << (int) m_rfeBoardState.channelIDTX
+ << "enableSWR: " << (int) m_rfeBoardState.enableSWR
+ << "mode: " << (int) m_rfeBoardState.mode
+ << "notchOnOff: " << (int) m_rfeBoardState.notchOnOff
+ << "selPortRX: " << (int) m_rfeBoardState.selPortRX
+ << "selPortTX: " << (int) m_rfeBoardState.selPortTX
+ << "sourceSWR: " << (int) m_rfeBoardState.sourceSWR;
+
+ if (rc != 0) {
+ qInfo("LimeRFEController::getState: %s", getError(rc).c_str());
+ }
+
+ return rc;
+}
+
+std::string LimeRFEController::getError(int errorCode)
+{
+ std::map::const_iterator it = m_errorCodesMap.find(errorCode);
+
+ if (it == m_errorCodesMap.end()) {
+ return "Unknown error";
+ } else {
+ return it->second;
+ }
+}
+
+int LimeRFEController::setRx(LimeRFESettings& settings, bool rxOn)
+{
+ if (!m_rfeDevice) {
+ return -1;
+ }
+
+ if (settings.m_txRxDriven) {
+ return 0;
+ }
+
+ int mode = rxOn && settings.m_txOn ?
+ RFE_MODE_TXRX : rxOn ?
+ RFE_MODE_RX : settings.m_txOn ?
+ RFE_MODE_TX : RFE_MODE_NONE;
+
+ int rc = RFE_Mode(m_rfeDevice, mode);
+
+ if (rc == 0) {
+ settings.m_rxOn = rxOn;
+ }
+
+ return rc;
+}
+
+int LimeRFEController::setTx(LimeRFESettings& settings, bool txOn)
+{
+ if (!m_rfeDevice) {
+ return -1;
+ }
+
+ if (settings.m_txRxDriven) {
+ return 0;
+ }
+
+ int mode = txOn && settings.m_rxOn ?
+ RFE_MODE_TXRX : txOn ?
+ RFE_MODE_TX : settings.m_rxOn ?
+ RFE_MODE_RX : RFE_MODE_NONE;
+
+ int rc = RFE_Mode(m_rfeDevice, mode);
+
+ if (rc == 0) {
+ settings.m_rxOn = txOn;
+ }
+
+ return rc;
+}
+
+int LimeRFEController::driveTx(LimeRFESettings& settings, bool txOn)
+{
+
+ if (!m_rfeDevice)
+ {
+ qDebug("LimeRFEController::driveTx: not open");
+ return -1;
+ }
+
+ if (settings.m_rxChannels == ChannelsCellular)
+ {
+ qDebug("LimeRFEController::driveTx: do nothing for cellular bands");
+ return 0; // cellular is TRX anyway
+ }
+
+ int mode = txOn ? RFE_MODE_TX : RFE_MODE_RX;
+ int rc = RFE_Mode(m_rfeDevice, mode);
+
+ if (rc == 0)
+ {
+ settings.m_rxOn = !txOn;
+ settings.m_txOn = txOn;
+ qDebug("LimeRFEController::driveTx: done: Rx: %s Tx: %s", settings.m_rxOn ? "on" : "off", settings.m_txOn ? "on" : "off");
+ }
+ else
+ {
+ qInfo("LimeRFEController::driveTx: %s error: %s", txOn ? "on" : "off", getError(rc).c_str());
+ }
+
+ return rc;
+}
+
+void LimeRFEController::settingsToState(const LimeRFESettings& settings)
+{
+ if (settings.m_rxChannels == ChannelsCellular)
+ {
+ if (settings.m_rxCellularChannel == CellularBand1)
+ {
+ m_rfeBoardState.channelIDRX = RFE_CID_CELL_BAND01;
+ m_rfeBoardState.mode = RFE_MODE_TXRX;
+ }
+ else if (settings.m_rxCellularChannel == CellularBand2)
+ {
+ m_rfeBoardState.channelIDRX = RFE_CID_CELL_BAND02;
+ m_rfeBoardState.mode = RFE_MODE_TXRX;
+ }
+ else if (settings.m_rxCellularChannel == CellularBand38)
+ {
+ m_rfeBoardState.channelIDRX = RFE_CID_CELL_BAND38;
+ }
+ else if (settings.m_rxCellularChannel == CellularBand7)
+ {
+ m_rfeBoardState.channelIDRX = RFE_CID_CELL_BAND07;
+ m_rfeBoardState.mode = RFE_MODE_TXRX;
+ }
+
+ m_rfeBoardState.selPortRX = RFE_PORT_1;
+ m_rfeBoardState.selPortTX = RFE_PORT_1;
+ m_rfeBoardState.channelIDTX = m_rfeBoardState.channelIDRX;
+ }
+ else
+ {
+ if (settings.m_rxChannels == ChannelsWideband)
+ {
+ if (settings.m_rxWidebandChannel == WidebandLow) {
+ m_rfeBoardState.channelIDRX = RFE_CID_WB_1000;
+ } else if (settings.m_rxWidebandChannel == WidebandHigh) {
+ m_rfeBoardState.channelIDRX = RFE_CID_WB_4000;
+ }
+ }
+ else if (settings.m_rxChannels == ChannelsHAM)
+ {
+ if (settings.m_rxHAMChannel == HAM_30M) {
+ m_rfeBoardState.channelIDRX = RFE_CID_HAM_0030;
+ } else if (settings.m_rxHAMChannel == HAM_50_70MHz) {
+ m_rfeBoardState.channelIDRX = RFE_CID_HAM_0070;
+ } else if (settings.m_rxHAMChannel == HAM_144_146MHz) {
+ m_rfeBoardState.channelIDRX = RFE_CID_HAM_0145;
+ } else if (settings.m_rxHAMChannel == HAM_220_225MHz) {
+ m_rfeBoardState.channelIDRX = RFE_CID_HAM_0220;
+ } else if (settings.m_rxHAMChannel == HAM_430_440MHz) {
+ m_rfeBoardState.channelIDRX = RFE_CID_HAM_0435;
+ } else if (settings.m_rxHAMChannel == HAM_902_928MHz) {
+ m_rfeBoardState.channelIDRX = RFE_CID_HAM_0920;
+ } else if (settings.m_rxHAMChannel == HAM_1240_1325MHz) {
+ m_rfeBoardState.channelIDRX = RFE_CID_HAM_1280;
+ } else if (settings.m_rxHAMChannel == HAM_2300_2450MHz) {
+ m_rfeBoardState.channelIDRX = RFE_CID_HAM_2400;
+ } else if (settings.m_rxHAMChannel == HAM_3300_3500MHz) {
+ m_rfeBoardState.channelIDRX = RFE_CID_HAM_3500;
+ }
+ }
+
+ if (settings.m_rxPort == RxPortJ3) {
+ m_rfeBoardState.selPortRX = RFE_PORT_1;
+ } else if (settings.m_rxPort == RxPortJ5) {
+ m_rfeBoardState.selPortRX = RFE_PORT_3;
+ }
+
+ if (settings.m_txRxDriven)
+ {
+ m_rfeBoardState.channelIDTX = m_rfeBoardState.channelIDRX;
+ }
+ else
+ {
+ if (settings.m_txChannels == ChannelsWideband)
+ {
+ if (settings.m_txWidebandChannel == WidebandLow) {
+ m_rfeBoardState.channelIDTX = RFE_CID_WB_1000;
+ } else if (settings.m_txWidebandChannel == WidebandHigh) {
+ m_rfeBoardState.channelIDTX = RFE_CID_WB_4000;
+ }
+ }
+ else if (settings.m_txChannels == ChannelsHAM)
+ {
+ if (settings.m_txHAMChannel == HAM_30M) {
+ m_rfeBoardState.channelIDTX = RFE_CID_HAM_0030;
+ } else if (settings.m_txHAMChannel == HAM_50_70MHz) {
+ m_rfeBoardState.channelIDTX = RFE_CID_HAM_0070;
+ } else if (settings.m_txHAMChannel == HAM_144_146MHz) {
+ m_rfeBoardState.channelIDTX = RFE_CID_HAM_0145;
+ } else if (settings.m_txHAMChannel == HAM_220_225MHz) {
+ m_rfeBoardState.channelIDTX = RFE_CID_HAM_0220;
+ } else if (settings.m_txHAMChannel == HAM_430_440MHz) {
+ m_rfeBoardState.channelIDTX = RFE_CID_HAM_0435;
+ } else if (settings.m_txHAMChannel == HAM_902_928MHz) {
+ m_rfeBoardState.channelIDTX = RFE_CID_HAM_0920;
+ } else if (settings.m_txHAMChannel == HAM_1240_1325MHz) {
+ m_rfeBoardState.channelIDTX = RFE_CID_HAM_1280;
+ } else if (settings.m_txHAMChannel == HAM_2300_2450MHz) {
+ m_rfeBoardState.channelIDTX = RFE_CID_HAM_2400;
+ } else if (settings.m_txHAMChannel == HAM_3300_3500MHz) {
+ m_rfeBoardState.channelIDTX = RFE_CID_HAM_3500;
+ }
+ }
+ }
+
+ if (settings.m_txPort == TxPortJ3) {
+ m_rfeBoardState.selPortTX = RFE_PORT_1;
+ } else if (settings.m_txPort == TxPortJ4) {
+ m_rfeBoardState.selPortTX = RFE_PORT_2;
+ } else if (settings.m_txPort == TxPortJ5) {
+ m_rfeBoardState.selPortTX = RFE_PORT_3;
+ }
+ }
+
+ m_rfeBoardState.attValue = settings.m_attenuationFactor < 0 ? 0 : settings.m_attenuationFactor > 7 ? 7 : settings.m_attenuationFactor;
+ m_rfeBoardState.notchOnOff = settings.m_amfmNotch;
+}
+
+void LimeRFEController::stateToSettings(LimeRFESettings& settings)
+{
+ if (m_rfeBoardState.channelIDRX == RFE_CID_CELL_BAND01)
+ {
+ settings.m_rxChannels = ChannelsCellular;
+ settings.m_rxCellularChannel = CellularBand1;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_CELL_BAND02)
+ {
+ settings.m_rxChannels = ChannelsCellular;
+ settings.m_rxCellularChannel = CellularBand2;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_CELL_BAND07)
+ {
+ settings.m_rxChannels = ChannelsCellular;
+ settings.m_rxCellularChannel = CellularBand7;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_CELL_BAND38)
+ {
+ settings.m_rxChannels = ChannelsCellular;
+ settings.m_rxCellularChannel = CellularBand38;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_WB_1000)
+ {
+ settings.m_rxChannels = ChannelsWideband;
+ settings.m_rxWidebandChannel = WidebandLow;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_WB_4000)
+ {
+ settings.m_rxChannels = ChannelsWideband;
+ settings.m_rxWidebandChannel = WidebandHigh;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0030)
+ {
+ settings.m_rxChannels = ChannelsHAM;
+ settings.m_rxHAMChannel = HAM_30M;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0070)
+ {
+ settings.m_rxChannels = ChannelsHAM;
+ settings.m_rxHAMChannel = HAM_50_70MHz;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0145)
+ {
+ settings.m_rxChannels = ChannelsHAM;
+ settings.m_rxHAMChannel = HAM_144_146MHz;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0220)
+ {
+ settings.m_rxChannels = ChannelsHAM;
+ settings.m_rxHAMChannel = HAM_220_225MHz;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0435)
+ {
+ settings.m_rxChannels = ChannelsHAM;
+ settings.m_rxHAMChannel = HAM_430_440MHz;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0920)
+ {
+ settings.m_rxChannels = ChannelsHAM;
+ settings.m_rxHAMChannel = HAM_902_928MHz;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_1280)
+ {
+ settings.m_rxChannels = ChannelsHAM;
+ settings.m_rxHAMChannel = HAM_1240_1325MHz;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_2400)
+ {
+ settings.m_rxChannels = ChannelsHAM;
+ settings.m_rxHAMChannel = HAM_2300_2450MHz;
+ }
+ else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_3500)
+ {
+ settings.m_rxChannels = ChannelsHAM;
+ settings.m_rxHAMChannel = HAM_3300_3500MHz;
+ }
+
+ if (m_rfeBoardState.selPortRX == RFE_PORT_1) {
+ settings.m_rxPort = RxPortJ3;
+ } else if (m_rfeBoardState.selPortRX == RFE_PORT_3) {
+ settings.m_rxPort = RxPortJ5;
+ }
+
+ if (m_rfeBoardState.channelIDTX == RFE_CID_CELL_BAND01)
+ {
+ settings.m_txChannels = ChannelsCellular;
+ settings.m_txCellularChannel = CellularBand1;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_CELL_BAND02)
+ {
+ settings.m_txChannels = ChannelsCellular;
+ settings.m_txCellularChannel = CellularBand2;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_CELL_BAND07)
+ {
+ settings.m_txChannels = ChannelsCellular;
+ settings.m_txCellularChannel = CellularBand7;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_CELL_BAND38)
+ {
+ settings.m_txChannels = ChannelsCellular;
+ settings.m_txCellularChannel = CellularBand38;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_WB_1000)
+ {
+ settings.m_txChannels = ChannelsWideband;
+ settings.m_txWidebandChannel = WidebandLow;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_WB_4000)
+ {
+ settings.m_txChannels = ChannelsWideband;
+ settings.m_txWidebandChannel = WidebandHigh;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0030)
+ {
+ settings.m_txChannels = ChannelsHAM;
+ settings.m_txHAMChannel = HAM_30M;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0070)
+ {
+ settings.m_txChannels = ChannelsHAM;
+ settings.m_txHAMChannel = HAM_50_70MHz;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0145)
+ {
+ settings.m_txChannels = ChannelsHAM;
+ settings.m_txHAMChannel = HAM_144_146MHz;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0220)
+ {
+ settings.m_txChannels = ChannelsHAM;
+ settings.m_txHAMChannel = HAM_220_225MHz;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0435)
+ {
+ settings.m_txChannels = ChannelsHAM;
+ settings.m_txHAMChannel = HAM_430_440MHz;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0920)
+ {
+ settings.m_txChannels = ChannelsHAM;
+ settings.m_txHAMChannel = HAM_902_928MHz;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_1280)
+ {
+ settings.m_txChannels = ChannelsHAM;
+ settings.m_txHAMChannel = HAM_1240_1325MHz;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_2400)
+ {
+ settings.m_txChannels = ChannelsHAM;
+ settings.m_txHAMChannel = HAM_2300_2450MHz;
+ }
+ else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_3500)
+ {
+ settings.m_txChannels = ChannelsHAM;
+ settings.m_txHAMChannel = HAM_3300_3500MHz;
+ }
+
+ if (m_rfeBoardState.selPortTX == RFE_PORT_1) {
+ settings.m_txPort = TxPortJ3;
+ } else if (m_rfeBoardState.selPortTX == RFE_PORT_2) {
+ settings.m_txPort = TxPortJ4;
+ } else if (m_rfeBoardState.selPortTX == RFE_PORT_3) {
+ settings.m_txPort = TxPortJ5;
+ }
+
+ settings.m_attenuationFactor = m_rfeBoardState.attValue;
+ settings.m_amfmNotch = m_rfeBoardState.notchOnOff == RFE_NOTCH_ON;
+
+ if (m_rfeBoardState.mode == RFE_MODE_RX)
+ {
+ settings.m_rxOn = true;
+ settings.m_txOn = false;
+ }
+ else if (m_rfeBoardState.mode == RFE_MODE_TX)
+ {
+ settings.m_rxOn = false;
+ settings.m_txOn = true;
+ }
+ else if (m_rfeBoardState.mode == RFE_MODE_NONE)
+ {
+ settings.m_rxOn = false;
+ settings.m_txOn = false;
+ }
+ else if (m_rfeBoardState.mode == RFE_MODE_TXRX)
+ {
+ settings.m_rxOn = true;
+ settings.m_txOn = true;
+ }
+}
diff --git a/sdrbase/limerfe/limerfecontroller.h b/sdrbase/limerfe/limerfecontroller.h
new file mode 100644
index 000000000..cd604a10f
--- /dev/null
+++ b/sdrbase/limerfe/limerfecontroller.h
@@ -0,0 +1,120 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2020 Edouard Griffiths, F4EXB //
+// //
+// This program 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 as version 3 of the License, or //
+// (at your option) any later version. //
+// //
+// This program 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 V3 for more details. //
+// //
+// You should have received a copy of the GNU General Public License //
+// along with this program. If not, see . //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef SDRBASE_LIMERFE_LIMERFECONTROLLER_H_
+#define SDRBASE_LIMERFE_LIMERFECONTROLLER_H_
+
+#include
+#include