Convert direct reference to string and freq table to vtxCommonXXX services

src/main/cms/cms_menu_vtx_rtc6705.c

@@ -44,9 +44,9 @@ static uint8_t cmsx_vtxBand;
 static uint8_t cmsx_vtxChannel;
 static uint8_t cmsx_vtxPower;
 
-static OSD_TAB_t entryVtxBand =         {&cmsx_vtxBand, VTX_RTC6705_BAND_COUNT - 1, &vtx58BandNames[1]};
+static OSD_TAB_t entryVtxBand;
-static OSD_UINT8_t entryVtxChannel =    {&cmsx_vtxChannel, 1, VTX_SETTINGS_CHANNEL_COUNT, 1};
+static OSD_UINT8_t entryVtxChannel;
-static OSD_TAB_t entryVtxPower =        {&cmsx_vtxPower, VTX_RTC6705_POWER_COUNT - 1 - VTX_RTC6705_MIN_POWER, &rtc6705PowerNames[VTX_RTC6705_MIN_POWER]};
+static OSD_TAB_t entryVtxPower;
 
 static void cmsx_Vtx_ConfigRead(void)
 {
@@ -61,7 +61,7 @@ static void cmsx_Vtx_ConfigWriteback(void)
     vtxSettingsConfigMutable()->band = cmsx_vtxBand + 1;
     vtxSettingsConfigMutable()->channel = cmsx_vtxChannel;
     vtxSettingsConfigMutable()->power = cmsx_vtxPower + VTX_RTC6705_MIN_POWER;
-    vtxSettingsConfigMutable()->freq = vtx58_Bandchan2Freq(cmsx_vtxBand + 1, cmsx_vtxChannel);
+    vtxSettingsConfigMutable()->freq = vtxCommonLookupFrequency(vtxCommonDevice(), cmsx_vtxBand + 1, cmsx_vtxChannel);
 
     saveConfigAndNotify();
 }
@@ -70,6 +70,21 @@ static long cmsx_Vtx_onEnter(void)
 {
     cmsx_Vtx_ConfigRead();
 
+    vtxDevice_t *device = vtxCommonDevice();
+
+    entryVtxBand.val = &cmsx_vtxBand;
+    entryVtxBand.max = device->capability.bandCount - 1;
+    entryVtxBand.names = &device->bandNames[1];
+
+    entryVtxChannel.val = &cmsx_vtxChannel;
+    entryVtxChannel.min = 1;
+    entryVtxChannel.max = device->capability.channelCount;
+    entryVtxChannel.step = 1;
+
+    entryVtxPower.val = &cmsx_vtxPower;
+    entryVtxPower.max = device->capability.powerCount - 1;
+    entryVtxPower.names = device->powerNames;
+
     return 0;
 }
 

src/main/cms/cms_menu_vtx_smartaudio.c

@@ -146,11 +146,13 @@ if (saDevice.version == 2) {
         saCmsPitFMode = 0;
 }
 
+    const vtxDevice_t *device = vtxCommonDevice();
+
     saCmsStatusString[0] = "-FR"[saCmsOpmodel];
 
     if (saCmsFselMode == 0) {
-        saCmsStatusString[2] = "ABEFR"[saDevice.channel / 8];
+        saCmsStatusString[2] = vtxCommonLookupBandLetter(device, saDevice.channel / 8 + 1);
-        saCmsStatusString[3] = '1' + (saDevice.channel % 8);
+        saCmsStatusString[3] = vtxCommonLookupChannelName(device, (saDevice.channel % 8) + 1)[0];
     } else {
         saCmsStatusString[2] = 'U';
         saCmsStatusString[3] = 'F';
@@ -162,8 +164,7 @@ if (saDevice.version == 2) {
     else if (saDevice.mode & SA_MODE_GET_FREQ_BY_FREQ)
         tfp_sprintf(&saCmsStatusString[5], "%4d", saDevice.freq);
     else
-        tfp_sprintf(&saCmsStatusString[5], "%4d",
+        tfp_sprintf(&saCmsStatusString[5], "%4d", vtxCommonLookupFrequency(vtxCommonDevice(), saDevice.channel / 8 + 1, saDevice.channel % 8 + 1));
-            vtx58frequencyTable[saDevice.channel / 8][saDevice.channel % 8]);
 
     saCmsStatusString[9] = ' ';
 
@@ -177,7 +178,8 @@ if (saDevice.version == 2) {
         saCmsStatusString[12] = 'R';
         saCmsStatusString[13] = 0;
     } else {
-        tfp_sprintf(&saCmsStatusString[10], "%3d", (saDevice.version == 2) ?  saPowerTable[saDevice.power].rfpower : saPowerTable[saDacToPowerIndex(saDevice.power)].rfpower);
+        int index = (saDevice.version == 2) ? saDevice.power : saDacToPowerIndex(saDevice.power);
+        tfp_sprintf(&saCmsStatusString[10], "%3d", vtxCommonLookupPowerName(vtxCommonDevice(), index + 1));
     }
 }
 
@@ -207,7 +209,7 @@ static long saCmsConfigBandByGvar(displayPort_t *pDisp, const void *self)
     if ((saCmsOpmodel == SACMS_OPMODEL_FREE) && !saDeferred)
         saSetBandAndChannel(saCmsBand - 1, saCmsChan - 1);
 
-    saCmsFreqRef = vtx58frequencyTable[saCmsBand - 1][saCmsChan - 1];
+    saCmsFreqRef = vtxCommonLookupFrequency(vtxCommonDevice(), saCmsBand, saCmsChan);
 
     return 0;
 }
@@ -232,7 +234,7 @@ static long saCmsConfigChanByGvar(displayPort_t *pDisp, const void *self)
     if ((saCmsOpmodel == SACMS_OPMODEL_FREE) && !saDeferred)
         saSetBandAndChannel(saCmsBand - 1, saCmsChan - 1);
 
-    saCmsFreqRef = vtx58frequencyTable[saCmsBand - 1][saCmsChan - 1];
+    saCmsFreqRef = vtxCommonLookupFrequency(vtxCommonDevice(), saCmsBand , saCmsChan);
 
     return 0;
 }
@@ -362,11 +364,26 @@ static CMS_Menu saCmsMenuStats = {
 };
 #endif /* USE_EXTENDED_CMS_MENUS */
 
-static OSD_TAB_t saCmsEntBand = { &saCmsBand, VTX_SMARTAUDIO_BAND_COUNT, vtx58BandNames };
+static OSD_TAB_t saCmsEntBand;
+static OSD_TAB_t saCmsEntChan;
+static OSD_TAB_t saCmsEntPower;
 
-static OSD_TAB_t saCmsEntChan = { &saCmsChan, VTX_SMARTAUDIO_CHANNEL_COUNT, vtx58ChannelNames };
+static void saCmsInitNames(void)
+{ 
+    vtxDevice_t *device = vtxCommonDevice();
 
-static OSD_TAB_t saCmsEntPower = { &saCmsPower, VTX_SMARTAUDIO_POWER_COUNT, saPowerNames};
+    saCmsEntBand.val = &saCmsBand;
+    saCmsEntBand.max = device->capability.bandCount;
+    saCmsEntBand.names = device->bandNames;
+
+    saCmsEntChan.val = &saCmsChan;
+    saCmsEntChan.max = device->capability.channelCount;
+    saCmsEntChan.names = device->channelNames;
+
+    saCmsEntPower.val = &saCmsPower;
+    saCmsEntPower.max = device->capability.powerCount;
+    saCmsEntPower.names = device->powerNames;
+}
 
 static OSD_UINT16_t saCmsEntFreqRef = { &saCmsFreqRef, 5600, 5900, 0 };
 
@@ -430,7 +447,7 @@ static long saCmsCommence(displayPort_t *pDisp, const void *self)
 
         newSettings.band = saCmsBand;
         newSettings.channel = saCmsChan;
-        newSettings.freq = vtx58_Bandchan2Freq(saCmsBand, saCmsChan);
+        newSettings.freq = vtxCommonLookupFrequency(vtxCommonDevice(), saCmsBand, saCmsChan);
         // If in pit mode, cancel it.
 
         if (saCmsPitFMode == 0)
@@ -443,7 +460,7 @@ static long saCmsCommence(displayPort_t *pDisp, const void *self)
         if (saCmsFselModeNew == 0) {
             newSettings.band = saCmsBand;
             newSettings.channel = saCmsChan;
-            newSettings.freq = vtx58_Bandchan2Freq(saCmsBand, saCmsChan);
+            newSettings.freq = vtxCommonLookupFrequency(vtxCommonDevice(), saCmsBand, saCmsChan);
         } else {
             saSetMode(0);    //make sure FREE mode is setup
             newSettings.band = 0;
@@ -664,6 +681,8 @@ static long sacms_SetupTopMenu(void)
         cmsx_menuVtxSmartAudio.entries = saCmsMenuOfflineEntries;
     }
 
+    saCmsInitNames();
+
     return 0;
 }
 

src/main/cms/cms_menu_vtx_tramp.c

@@ -46,10 +46,11 @@ char trampCmsStatusString[31] = "- -- ---- ----";
 
 void trampCmsUpdateStatusString(void)
 {
+    vtxDevice_t *vtxDevice = vtxCommonDevice();
     trampCmsStatusString[0] = '*';
     trampCmsStatusString[1] = ' ';
-    trampCmsStatusString[2] = vtx58BandLetter[trampBand];
+    trampCmsStatusString[2] = vtxCommonLookupBandLetter(vtxDevice, trampBand);
-    trampCmsStatusString[3] = vtx58ChannelNames[trampChannel][0];
+    trampCmsStatusString[3] = vtxCommonLookupChannelName(vtxDevice, trampChannel)[0];
     trampCmsStatusString[4] = ' ';
 
     if (trampCurFreq)
@@ -69,20 +70,20 @@ uint8_t trampCmsBand = 1;
 uint8_t trampCmsChan = 1;
 uint16_t trampCmsFreqRef;
 
-static OSD_TAB_t trampCmsEntBand = { &trampCmsBand, VTX_TRAMP_BAND_COUNT, vtx58BandNames };
+static OSD_TAB_t trampCmsEntBand;
-
+static OSD_TAB_t trampCmsEntChan;
-static OSD_TAB_t trampCmsEntChan = { &trampCmsChan, VTX_TRAMP_CHANNEL_COUNT, vtx58ChannelNames };
 
 static OSD_UINT16_t trampCmsEntFreqRef = { &trampCmsFreqRef, 5600, 5900, 0 };
 
 static uint8_t trampCmsPower = 1;
 
-static OSD_TAB_t trampCmsEntPower = { &trampCmsPower, sizeof(trampPowerTable), trampPowerNames };
+static OSD_TAB_t trampCmsEntPower;
 
 static void trampCmsUpdateFreqRef(void)
 {
-    if (trampCmsBand > 0 && trampCmsChan > 0)
+    if (trampCmsBand > 0 && trampCmsChan > 0) {
-        trampCmsFreqRef = vtx58frequencyTable[trampCmsBand - 1][trampCmsChan - 1];
+        trampCmsFreqRef = vtxCommonLookupFrequency(vtxCommonDevice(), trampCmsBand, trampCmsChan);
+    }
 }
 
 static long trampCmsConfigBand(displayPort_t *pDisp, const void *self)
@@ -153,8 +154,9 @@ static long trampCmsCommence(displayPort_t *pDisp, const void *self)
     UNUSED(pDisp);
     UNUSED(self);
 
-    trampSetBandAndChannel(trampCmsBand, trampCmsChan);
+    vtxDevice_t *device = vtxCommonDevice();
-    trampSetRFPower(trampPowerTable[trampCmsPower-1]);
+    vtxCommonSetBandAndChannel(device, trampCmsBand, trampCmsChan);
+    vtxCommonSetPowerByIndex(device, trampCmsPower);
 
     // If it fails, the user should retry later
     trampCommitChanges();
@@ -163,7 +165,7 @@ static long trampCmsCommence(displayPort_t *pDisp, const void *self)
     vtxSettingsConfigMutable()->band = trampCmsBand;
     vtxSettingsConfigMutable()->channel = trampCmsChan;
     vtxSettingsConfigMutable()->power = trampCmsPower;
-    vtxSettingsConfigMutable()->freq = vtx58_Bandchan2Freq(trampCmsBand, trampCmsChan);
+    vtxSettingsConfigMutable()->freq = vtxCommonLookupFrequency(vtxCommonDevice(), trampCmsBand, trampCmsChan);
 
     saveConfigAndNotify();
 
@@ -179,13 +181,22 @@ static void trampCmsInitSettings(void)
     trampCmsPitMode = trampPitMode + 1;
 
     if (trampConfiguredPower > 0) {
-        for (uint8_t i = 0; i < VTX_TRAMP_POWER_COUNT; i++) {
+        trampCmsPower = vtxCommonGetPowerIndex(vtxCommonDevice(), &trampCmsPower);
-            if (trampConfiguredPower <= trampPowerTable[i]) {
-                trampCmsPower = i + 1;
-                break;
-            }
-        }
     }
+
+    vtxDevice_t *device = vtxCommonDevice();
+
+    trampCmsEntBand.val = &trampCmsBand;
+    trampCmsEntBand.max = device->capability.bandCount;
+    trampCmsEntBand.names = device->bandNames;
+
+    trampCmsEntChan.val = &trampCmsChan;
+    trampCmsEntChan.max = device->capability.channelCount;
+    trampCmsEntChan.names = device->channelNames;
+
+    trampCmsEntPower.val = &trampCmsPower;
+    trampCmsEntPower.max = device->capability.powerCount;
+    trampCmsEntPower.names = device->powerNames;
 }
 
 static long trampCmsOnEnter(void)

src/main/drivers/vtx_common.c

@@ -126,4 +126,63 @@ bool vtxCommonGetDeviceCapability(const vtxDevice_t *vtxDevice, vtxDeviceCapabil
     return true;
 }
 
+const char *vtxCommonLookupBandName(const vtxDevice_t *vtxDevice, int band)
+{
+    return vtxDevice->bandNames[band];
+}
+
+char vtxCommonLookupBandLetter(const vtxDevice_t *vtxDevice, int band)
+{
+    return vtxDevice->bandLetters[band];
+}
+
+const char *vtxCommonLookupChannelName(const vtxDevice_t *vtxDevice, int channel)
+{
+    return vtxDevice->channelNames[channel];
+}
+
+//Converts frequency (in MHz) to band and channel values.
+bool vtxCommonLookupBandChan(const vtxDevice_t *vtxDevice, uint16_t freq, uint8_t *pBand, uint8_t *pChannel)
+{
+    // Use reverse lookup order so that 5880Mhz
+    // get Raceband 7 instead of Fatshark 8.
+    for (int band = vtxDevice->capability.bandCount - 1 ; band >= 0 ; band--) {
+        for (int channel = 0 ; channel < vtxDevice->capability.channelCount ; channel++) {
+            if (vtxDevice->frequencyTable[band * vtxDevice->capability.channelCount + channel] == freq) {
+                *pBand = band + 1;
+                *pChannel = channel + 1;
+                return true;
+            }
+        }
+    }
+
+    *pBand = 0;
+    *pChannel = 0;
+
+    return false;
+}
+
+//Converts band and channel values to a frequency (in MHz) value.
+// band:  Band value (1 to 5).
+// channel:  Channel value (1 to 8).
+// Returns frequency value (in MHz), or 0 if band/channel out of range.
+uint16_t vtxCommonLookupFrequency(const vtxDevice_t *vtxDevice, int band, int channel)
+{
+    if (band > 0 && band <= vtxDevice->capability.bandCount &&
+                          channel > 0 && channel <= vtxDevice->capability.channelCount) {
+        return vtxDevice->frequencyTable[(band - 1) * vtxDevice->capability.channelCount + (channel - 1)];
+
+    }
+    return 0;
+}
+
+const char *vtxCommonLookupPowerName(const vtxDevice_t *vtxDevice, int index)
+{
+    return vtxDevice->powerNames[index];
+}
+
+uint16_t vtxCommonLookupPowerValue(const vtxDevice_t *vtxDevice, int index)
+{
+    return vtxDevice->powerValues[index];
+}
 #endif

src/main/drivers/vtx_common.h

@@ -121,10 +121,12 @@ typedef struct vtxDevice_s {
 
     vtxDeviceCapability_t capability;
 
-    uint16_t *frequencyTable;  // Array of [bandCount][channelCount]
+    const uint16_t *frequencyTable;  // Array of [bandCount][channelCount]
-    char **bandNames;    // char *bandNames[bandCount]
+    const char **bandNames;          // char *bandNames[bandCount + 1]
-    char **channelNames;    // char *channelNames[channelCount]
+    const char **channelNames;       // char *channelNames[channelCount + 1]
-    char **powerNames;   // char *powerNames[powerCount]
+    const char *bandLetters;         // char bandLetters[bandCount + 1]
+    const uint16_t *powerValues;     // uint16 powerValues[powerCount]
+    const char **powerNames;         // char *powerNames[powerCount + 1]
 
     uint16_t frequency;
     uint8_t band; // Band = 1, 1-based
@@ -176,3 +178,11 @@ bool vtxCommonGetPowerIndex(const vtxDevice_t *vtxDevice, uint8_t *pIndex);
 bool vtxCommonGetPitMode(const vtxDevice_t *vtxDevice, uint8_t *pOnOff);
 bool vtxCommonGetFrequency(const vtxDevice_t *vtxDevice, uint16_t *pFreq);
 bool vtxCommonGetDeviceCapability(const vtxDevice_t *vtxDevice, vtxDeviceCapability_t *pDeviceCapability);
+const char *vtxCommonLookupBandName(const vtxDevice_t *vtxDevice, int band);
+char vtxCommonLookupBandLetter(const vtxDevice_t *vtxDevice, int band);
+char vtxCommonGetBandLetter(const vtxDevice_t *vtxDevice, int band);
+const char *vtxCommonLookupChannelName(const vtxDevice_t *vtxDevice, int channel);
+uint16_t vtxCommonLookupFrequency(const vtxDevice_t *vtxDevice, int band, int channel);
+bool vtxCommonLookupBandChan(const vtxDevice_t *vtxDevice, uint16_t freq, uint8_t *pBand, uint8_t *pChannel);
+const char *vtxCommonLookupPowerName(const vtxDevice_t *vtxDevice, int index);
+uint16_t vtxCommonLookupPowerValue(const vtxDevice_t *vtxDevice, int index);

src/main/interface/msp.c

@@ -2003,7 +2003,7 @@ static mspResult_e mspProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
                 const uint8_t newChannel = (newFrequency % 8) + 1;
                 vtxSettingsConfigMutable()->band = newBand;
                 vtxSettingsConfigMutable()->channel = newChannel;
-                vtxSettingsConfigMutable()->freq = vtx58_Bandchan2Freq(newBand, newChannel);
+                vtxSettingsConfigMutable()->freq = vtxCommonLookupFrequency(vtxDevice, newBand, newChannel);
             } else if (newFrequency <= VTX_SETTINGS_MAX_FREQUENCY_MHZ) { // Value is frequency in MHz
                 vtxSettingsConfigMutable()->band = 0;
                 vtxSettingsConfigMutable()->channel = 0;

src/main/io/ledstrip.c

@@ -611,8 +611,8 @@ static void applyLedVtxLayer(bool updateNow, timeUs_t *timer)
         vtxCommonGetPowerIndex(vtxDevice, &power);
         vtxCommonGetPitMode(vtxDevice, &pit);
 
-        frequency = vtx58frequencyTable[band - 1][channel - 1]; //subtracting 1 from band and channel so that correct frequency is returned.
+        frequency = vtxCommonLookupFrequency(vtxDevice, band, channel);
-                                                                //might not be correct for tramp but should fix smart audio.
+
         // check if last vtx values have changed.
         check = pit + (power << 1) + (band << 4) + (channel << 8);
         if (!showSettings && check != lastCheck) {

src/main/io/osd.c

@@ -811,10 +811,10 @@ static bool osdDrawSingleElement(uint8_t item)
 #if defined(USE_VTX_COMMON)
     case OSD_VTX_CHANNEL:
         {
-            const char vtxBandLetter = vtx58BandLetter[vtxSettingsConfig()->band];
-            const char *vtxChannelName = vtx58ChannelNames[vtxSettingsConfig()->channel];
-            uint8_t vtxPower = vtxSettingsConfig()->power;
             const vtxDevice_t *vtxDevice = vtxCommonDevice();
+            const char vtxBandLetter = vtxCommonLookupBandLetter(vtxDevice, vtxSettingsConfig()->band);
+            const char *vtxChannelName = vtxCommonLookupChannelName(vtxDevice, vtxSettingsConfig()->channel);
+            uint8_t vtxPower = vtxSettingsConfig()->power;
             if (vtxDevice && vtxSettingsConfig()->lowPowerDisarm) {
                 vtxCommonGetPowerIndex(vtxDevice, &vtxPower);
             }

src/main/io/spektrum_vtx_control.c

@@ -200,7 +200,7 @@ void spektrumVtxControl(void)
         if ((prevSettings.band != band) || (prevSettings.channel != channel)) {
             newSettings.band    = band;
             newSettings.channel = channel;
-            newSettings.freq    = vtx58_Bandchan2Freq(band, channel);
+            newSettings.freq    = vtxCommonLookupFrequency(vtxDevice, band, channel);
         }
 #endif
         // Seems to be no unified internal VTX API standard for power levels/indexes, VTX device brand specific.

src/main/io/vtx.c

@@ -70,7 +70,7 @@ void vtxInit(void)
     bool settingsUpdated = false;
 
     // sync frequency in parameter group when band/channel are specified
-    const uint16_t freq = vtx58_Bandchan2Freq(vtxSettingsConfig()->band, vtxSettingsConfig()->channel);
+    const uint16_t freq = vtxCommonLookupFrequency(vtxCommonDevice(), vtxSettingsConfig()->band, vtxSettingsConfig()->channel);
     if (vtxSettingsConfig()->band && freq != vtxSettingsConfig()->freq) {
         vtxSettingsConfigMutable()->freq = freq;
         settingsUpdated = true;

src/main/io/vtx_rtc6705.c

@@ -41,7 +41,7 @@
 
 
 #if defined(USE_CMS) || defined(USE_VTX_COMMON)
-const char * const rtc6705PowerNames[] = {
+const char * rtc6705PowerNames[] = {
     "OFF", "MIN", "MAX"
 };
 #endif
@@ -50,12 +50,6 @@ const char * const rtc6705PowerNames[] = {
 static vtxVTable_t rtc6705VTable;    // Forward
 static vtxDevice_t vtxRTC6705 = {
     .vTable = &rtc6705VTable,
-    .capability.bandCount = VTX_SETTINGS_BAND_COUNT,
-    .capability.channelCount = VTX_SETTINGS_CHANNEL_COUNT,
-    .capability.powerCount = VTX_RTC6705_POWER_COUNT,
-    .bandNames = (char **)vtx58BandNames,
-    .channelNames = (char **)vtx58ChannelNames,
-    .powerNames = (char **)rtc6705PowerNames,
 };
 #endif
 
@@ -64,6 +58,15 @@ static void vtxRTC6705SetFrequency(vtxDevice_t *vtxDevice, uint16_t frequency);
 
 bool vtxRTC6705Init(void)
 {
+    vtxRTC6705.capability.bandCount = VTX_SETTINGS_BAND_COUNT,
+    vtxRTC6705.capability.channelCount = VTX_SETTINGS_CHANNEL_COUNT,
+    vtxRTC6705.capability.powerCount = VTX_RTC6705_POWER_COUNT,
+    vtxRTC6705.frequencyTable = vtxStringFrequencyTable();
+    vtxRTC6705.bandNames = vtxStringBandNames();
+    vtxRTC6705.bandLetters = vtxStringBandLetters();
+    vtxRTC6705.channelNames = vtxStringChannelNames();
+    vtxRTC6705.powerNames = rtc6705PowerNames,
+
     vtxCommonSetDevice(&vtxRTC6705);
 
     return true;
@@ -126,7 +129,7 @@ static void vtxRTC6705SetBandAndChannel(vtxDevice_t *vtxDevice, uint8_t band, ui
         if (vtxDevice->powerIndex > 0) {
             vtxDevice->band = band;
             vtxDevice->channel = channel;
-            vtxRTC6705SetFrequency(vtxDevice, vtx58frequencyTable[band-1][channel-1]);
+            vtxRTC6705SetFrequency(vtxDevice, vtxCommonLookupFrequency(vtxDevice, band, channel));
         }
     }
 }

src/main/io/vtx_rtc6705.h

@@ -25,7 +25,5 @@
 
 #include "platform.h"
 
-extern const char * const rtc6705PowerNames[];
-
 bool vtxRTC6705CanUpdate(void);
 bool vtxRTC6705Init(void);

src/main/io/vtx_smartaudio.c

@@ -63,8 +63,10 @@ serialPort_t *debugSerialPort = NULL;
 
 static serialPort_t *smartAudioSerialPort = NULL;
 
+smartAudioDevice_t saDevice;
+
 #if defined(USE_CMS) || defined(USE_VTX_COMMON)
-const char * const saPowerNames[VTX_SMARTAUDIO_POWER_COUNT+1] = {
+const char * saPowerNames[VTX_SMARTAUDIO_POWER_COUNT+1] = {
     "---", "25 ", "200", "500", "800",
 };
 #endif
@@ -73,12 +75,6 @@ const char * const saPowerNames[VTX_SMARTAUDIO_POWER_COUNT+1] = {
 static const vtxVTable_t saVTable;    // Forward
 static vtxDevice_t vtxSmartAudio = {
     .vTable = &saVTable,
-    .capability.bandCount = VTX_SMARTAUDIO_BAND_COUNT,
-    .capability.channelCount = VTX_SMARTAUDIO_CHANNEL_COUNT,
-    .capability.powerCount = VTX_SMARTAUDIO_POWER_COUNT,
-    .bandNames = (char **)vtx58BandNames,
-    .channelNames = (char **)vtx58ChannelNames,
-    .powerNames = (char **)saPowerNames,
 };
 #endif
 
@@ -127,6 +123,10 @@ saPowerTable_t saPowerTable[VTX_SMARTAUDIO_POWER_COUNT] = {
     { 800,  40,   3 },
 };
 
+uint16_t saPowerValues[VTX_SMARTAUDIO_POWER_COUNT] = {
+    25, 200, 500, 800
+};
+
 // Last received device ('hard') states
 
 smartAudioDevice_t saDevice = {
@@ -694,6 +694,16 @@ bool vtxSmartAudioInit(void)
         return false;
     }
 
+    vtxSmartAudio.capability.bandCount = VTX_SMARTAUDIO_BAND_COUNT;
+    vtxSmartAudio.capability.channelCount = VTX_SMARTAUDIO_CHANNEL_COUNT;
+    vtxSmartAudio.capability.powerCount = VTX_SMARTAUDIO_POWER_COUNT;
+    vtxSmartAudio.frequencyTable = vtxStringFrequencyTable();
+    vtxSmartAudio.bandNames = vtxStringBandNames();
+    vtxSmartAudio.bandLetters = vtxStringBandLetters();
+    vtxSmartAudio.channelNames = vtxStringChannelNames();
+    vtxSmartAudio.powerNames = saPowerNames;
+    vtxSmartAudio.powerValues = saPowerValues;
+
     vtxCommonSetDevice(&vtxSmartAudio);
 
     return true;
@@ -885,8 +895,9 @@ static bool vtxSAGetFreq(const vtxDevice_t *vtxDevice, uint16_t *pFreq)
 
     // if not in user-freq mode then convert band/chan to frequency
     *pFreq = (saDevice.mode & SA_MODE_GET_FREQ_BY_FREQ) ? saDevice.freq :
-        vtx58_Bandchan2Freq(SA_DEVICE_CHVAL_TO_BAND(saDevice.channel) + 1,
+        vtxCommonLookupFrequency(&vtxSmartAudio,
-        SA_DEVICE_CHVAL_TO_CHANNEL(saDevice.channel) + 1);
+                SA_DEVICE_CHVAL_TO_BAND(saDevice.channel) + 1,
+                SA_DEVICE_CHVAL_TO_CHANNEL(saDevice.channel) + 1);
     return true;
 }
 

src/main/io/vtx_smartaudio.h

@@ -88,8 +88,6 @@ typedef struct smartAudioStat_s {
 } smartAudioStat_t;
 
 extern smartAudioDevice_t saDevice;
-extern saPowerTable_t saPowerTable[];
-extern const char * const saPowerNames[];
 extern smartAudioStat_t saStat;
 
 extern uint16_t sa_smartbaud;

src/main/io/vtx_string.c

@@ -32,7 +32,7 @@
 #define VTX_STRING_BAND_COUNT 5
 #define VTX_STRING_CHAN_COUNT 8
 
-const uint16_t vtx58frequencyTable[VTX_STRING_BAND_COUNT][VTX_STRING_CHAN_COUNT] =
+static const uint16_t vtx58frequencyTable[VTX_STRING_BAND_COUNT][VTX_STRING_CHAN_COUNT] =
 {
     { 5865, 5845, 5825, 5805, 5785, 5765, 5745, 5725 }, // Boscam A
     { 5733, 5752, 5771, 5790, 5809, 5828, 5847, 5866 }, // Boscam B
@@ -41,7 +41,7 @@ const uint16_t vtx58frequencyTable[VTX_STRING_BAND_COUNT][VTX_STRING_CHAN_COUNT]
     { 5658, 5695, 5732, 5769, 5806, 5843, 5880, 5917 }, // RaceBand
 };
 
-const char * const vtx58BandNames[] = {
+static const char * vtx58BandNames[] = {
     "--------",
     "BOSCAM A",
     "BOSCAM B",
@@ -50,44 +50,30 @@ const char * const vtx58BandNames[] = {
     "RACEBAND",
 };
 
-const char vtx58BandLetter[] = "-ABEFR";
+static char const vtx58BandLetter[] = "-ABEFR";
 
-const char * const vtx58ChannelNames[] = {
+static char const * vtx58ChannelNames[] = {
     "-", "1", "2", "3", "4", "5", "6", "7", "8",
 };
 
-//Converts frequency (in MHz) to band and channel values.
+const uint16_t *vtxStringFrequencyTable(void)
-bool vtx58_Freq2Bandchan(uint16_t freq, uint8_t *pBand, uint8_t *pChannel)
 {
-    // Use reverse lookup order so that 5880Mhz
+    return &vtx58frequencyTable[0][0];
-    // get Raceband 7 instead of Fatshark 8.
-    for (int band = VTX_STRING_BAND_COUNT - 1 ; band >= 0 ; band--) {
-        for (int channel = 0 ; channel < VTX_STRING_CHAN_COUNT ; channel++) {
-            if (vtx58frequencyTable[band][channel] == freq) {
-                *pBand = band + 1;
-                *pChannel = channel + 1;
-                return true;
-            }
-        }
-    }
-
-    *pBand = 0;
-    *pChannel = 0;
-
-    return false;
 }
 
-//Converts band and channel values to a frequency (in MHz) value.
+const char **vtxStringBandNames(void)
-// band:  Band value (1 to 5).
-// channel:  Channel value (1 to 8).
-// Returns frequency value (in MHz), or 0 if band/channel out of range.
-uint16_t vtx58_Bandchan2Freq(uint8_t band, uint8_t channel)
 {
-    if (band > 0 && band <= VTX_STRING_BAND_COUNT &&
+    return vtx58BandNames;
-                          channel > 0 && channel <= VTX_STRING_CHAN_COUNT) {
+}
-        return vtx58frequencyTable[band - 1][channel - 1];
+
-    }
+const char **vtxStringChannelNames(void)
-    return 0;
+{
+    return vtx58ChannelNames;
+}
+
+const char *vtxStringBandLetters(void)
+{
+    return vtx58BandLetter;
 }
 
 #endif

src/main/io/vtx_string.h

@@ -25,11 +25,10 @@
 #include "platform.h"
 #include "drivers/vtx_common.h"
 
+bool _vtxStringFreq2Bandchan(uint16_t freq, uint8_t *pBand, uint8_t *pChannel);
+uint16_t _vtxStringBandchan2Freq(uint8_t band, uint8_t channel);
 
-extern const uint16_t vtx58frequencyTable[VTX_SETTINGS_BAND_COUNT][VTX_SETTINGS_CHANNEL_COUNT];
+const uint16_t * vtxStringFrequencyTable(void);
-extern const char * const vtx58BandNames[];
+const char ** vtxStringBandNames(void);
-extern const char * const vtx58ChannelNames[];
+const char ** vtxStringChannelNames(void);
-extern const char vtx58BandLetter[];
+const char * vtxStringBandLetters(void);
-
-bool vtx58_Freq2Bandchan(uint16_t freq, uint8_t *pBand, uint8_t *pChannel);
-uint16_t vtx58_Bandchan2Freq(uint8_t band, uint8_t channel);

src/main/io/vtx_tramp.c

@@ -49,7 +49,7 @@ const uint16_t trampPowerTable[VTX_TRAMP_POWER_COUNT] = {
     25, 100, 200, 400, 600
 };
 
-const char * const trampPowerNames[VTX_TRAMP_POWER_COUNT+1] = {
+const char * trampPowerNames[VTX_TRAMP_POWER_COUNT+1] = {
     "---", "25 ", "100", "200", "400", "600"
 };
 #endif
@@ -58,12 +58,6 @@ const char * const trampPowerNames[VTX_TRAMP_POWER_COUNT+1] = {
 static const vtxVTable_t trampVTable; // forward
 static vtxDevice_t vtxTramp = {
     .vTable = &trampVTable,
-    .capability.bandCount = VTX_TRAMP_BAND_COUNT,
-    .capability.channelCount = VTX_TRAMP_CHANNEL_COUNT,
-    .capability.powerCount = sizeof(trampPowerTable),
-    .bandNames = (char **)vtx58BandNames,
-    .channelNames = (char **)vtx58ChannelNames,
-    .powerNames = (char **)trampPowerNames,
 };
 #endif
 
@@ -167,7 +161,7 @@ static bool trampValidateBandAndChannel(uint8_t band, uint8_t channel)
 
 static void trampDevSetBandAndChannel(uint8_t band, uint8_t channel)
 {
-    trampDevSetFreq(vtx58_Bandchan2Freq(band, channel));
+    trampDevSetFreq(vtxCommonLookupFrequency(vtxCommonDevice(), band, channel));
 }
 
 void trampSetBandAndChannel(uint8_t band, uint8_t channel)
@@ -246,7 +240,7 @@ static char trampHandleResponse(void)
                 trampPower = trampRespBuffer[8]|(trampRespBuffer[9] << 8);
 
                 // if no band/chan match then make sure set-by-freq mode is flagged
-                if (!vtx58_Freq2Bandchan(trampCurFreq, &trampBand, &trampChannel)) {
+                if (!vtxCommonLookupBandChan(vtxCommonDevice(), trampCurFreq, &trampBand, &trampChannel)) {
                     trampSetByFreqFlag = true;
                 }
 
@@ -621,6 +615,16 @@ bool vtxTrampInit(void)
     }
 
 #if defined(USE_VTX_COMMON)
+    vtxTramp.capability.bandCount = VTX_TRAMP_BAND_COUNT;
+    vtxTramp.capability.channelCount = VTX_TRAMP_CHANNEL_COUNT;
+    vtxTramp.capability.powerCount = sizeof(trampPowerTable),
+    vtxTramp.frequencyTable = vtxStringFrequencyTable();
+    vtxTramp.bandNames = vtxStringBandNames();
+    vtxTramp.bandLetters = vtxStringBandLetters();
+    vtxTramp.channelNames = vtxStringChannelNames();
+    vtxTramp.powerNames = trampPowerNames;
+    vtxTramp.powerValues = trampPowerTable;
+
     vtxCommonSetDevice(&vtxTramp);
 #endif
 

src/main/io/vtx_tramp.h

@@ -36,9 +36,6 @@
 #define VTX_TRAMP_MIN_FREQUENCY_MHZ 5000             //min freq in MHz
 #define VTX_TRAMP_MAX_FREQUENCY_MHZ 5999             //max freq in MHz
 
-extern const uint16_t trampPowerTable[VTX_TRAMP_POWER_COUNT];
-extern const char * const trampPowerNames[VTX_TRAMP_POWER_COUNT+1];
-
 extern uint8_t trampBand;
 extern uint8_t trampChannel;
 extern uint16_t trampPower;       // Actual transmitting power

src/main/telemetry/srxl.c

@@ -314,13 +314,13 @@ static void convertVtxPower(spektrumVtx_t * vtx)
 #if defined(USE_VTX_TRAMP)
         case VTXDEV_TRAMP:
             powerIndexTable = vtxTrampPi;
-            vtx->powerValue = trampPowerTable[vtx->power -1];      // Lookup the device power value, 0-based table vs 1-based index. Doh.
+            vtx->powerValue = vtxCommonLookupPowerValue(vtxCommonDevice(), vtx->power - 1);  // Lookup the device power value, 0-based table vs 1-based index. Doh.
             break;
 #endif
 #if defined(USE_VTX_SMARTAUDIO)
         case VTXDEV_SMARTAUDIO:
             powerIndexTable = vtxSaPi;
-            vtx->powerValue = saPowerTable[vtx->power -1].rfpower;
+            vtx->powerValue = vtxCommonLookupPowerValue(vtxCommonDevice(), vtx->power - 1);  // Lookup the device power value, 0-based table vs 1-based index. Doh.
             break;
 #endif
 #if defined(USE_VTX_RTC6705)