diff --git a/src/main/cms/cms_menu_vtx_rtc6705.c b/src/main/cms/cms_menu_vtx_rtc6705.c index a3c55b200c..864e5649c9 100644 --- a/src/main/cms/cms_menu_vtx_rtc6705.c +++ b/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_UINT8_t entryVtxChannel = {&cmsx_vtxChannel, 1, VTX_SETTINGS_CHANNEL_COUNT, 1}; -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 entryVtxBand; +static OSD_UINT8_t entryVtxChannel; +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; } diff --git a/src/main/cms/cms_menu_vtx_smartaudio.c b/src/main/cms/cms_menu_vtx_smartaudio.c index ec6abbd956..33f75f60aa 100644 --- a/src/main/cms/cms_menu_vtx_smartaudio.c +++ b/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[3] = '1' + (saDevice.channel % 8); + saCmsStatusString[2] = vtxCommonLookupBandLetter(device, saDevice.channel / 8 + 1); + 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", - vtx58frequencyTable[saDevice.channel / 8][saDevice.channel % 8]); + tfp_sprintf(&saCmsStatusString[5], "%4d", vtxCommonLookupFrequency(vtxCommonDevice(), saDevice.channel / 8 + 1, saDevice.channel % 8 + 1)); 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; } diff --git a/src/main/cms/cms_menu_vtx_tramp.c b/src/main/cms/cms_menu_vtx_tramp.c index 4ad63a6a65..a4724d22b5 100644 --- a/src/main/cms/cms_menu_vtx_tramp.c +++ b/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[3] = vtx58ChannelNames[trampChannel][0]; + trampCmsStatusString[2] = vtxCommonLookupBandLetter(vtxDevice, trampBand); + 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 trampCmsEntChan = { &trampCmsChan, VTX_TRAMP_CHANNEL_COUNT, vtx58ChannelNames }; +static OSD_TAB_t trampCmsEntBand; +static OSD_TAB_t trampCmsEntChan; 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) - trampCmsFreqRef = vtx58frequencyTable[trampCmsBand - 1][trampCmsChan - 1]; + if (trampCmsBand > 0 && trampCmsChan > 0) { + 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); - trampSetRFPower(trampPowerTable[trampCmsPower-1]); + vtxDevice_t *device = vtxCommonDevice(); + 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++) { - if (trampConfiguredPower <= trampPowerTable[i]) { - trampCmsPower = i + 1; - break; - } - } + trampCmsPower = vtxCommonGetPowerIndex(vtxCommonDevice(), &trampCmsPower); } + + 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) diff --git a/src/main/drivers/vtx_common.c b/src/main/drivers/vtx_common.c index 1baaba6930..56c611393b 100644 --- a/src/main/drivers/vtx_common.c +++ b/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 diff --git a/src/main/drivers/vtx_common.h b/src/main/drivers/vtx_common.h index 7b28e0af27..05d83ce57d 100644 --- a/src/main/drivers/vtx_common.h +++ b/src/main/drivers/vtx_common.h @@ -121,10 +121,12 @@ typedef struct vtxDevice_s { vtxDeviceCapability_t capability; - uint16_t *frequencyTable; // Array of [bandCount][channelCount] - char **bandNames; // char *bandNames[bandCount] - char **channelNames; // char *channelNames[channelCount] - char **powerNames; // char *powerNames[powerCount] + const uint16_t *frequencyTable; // Array of [bandCount][channelCount] + const char **bandNames; // char *bandNames[bandCount + 1] + const char **channelNames; // char *channelNames[channelCount + 1] + 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); diff --git a/src/main/interface/msp.c b/src/main/interface/msp.c index 55a900c754..bcb7f03176 100644 --- a/src/main/interface/msp.c +++ b/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; diff --git a/src/main/io/ledstrip.c b/src/main/io/ledstrip.c index 0dd4d2ec9d..a21d9f5fde 100644 --- a/src/main/io/ledstrip.c +++ b/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. - //might not be correct for tramp but should fix smart audio. + frequency = vtxCommonLookupFrequency(vtxDevice, band, channel); + // check if last vtx values have changed. check = pit + (power << 1) + (band << 4) + (channel << 8); if (!showSettings && check != lastCheck) { diff --git a/src/main/io/osd.c b/src/main/io/osd.c index 316a7745c0..0ec35f894f 100644 --- a/src/main/io/osd.c +++ b/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); } diff --git a/src/main/io/spektrum_vtx_control.c b/src/main/io/spektrum_vtx_control.c index a634aca274..df51d8c1b5 100644 --- a/src/main/io/spektrum_vtx_control.c +++ b/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. diff --git a/src/main/io/vtx.c b/src/main/io/vtx.c index 36ffc2aa82..15c8f004e8 100644 --- a/src/main/io/vtx.c +++ b/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; diff --git a/src/main/io/vtx_rtc6705.c b/src/main/io/vtx_rtc6705.c index a2c4c4387b..cb2a372643 100644 --- a/src/main/io/vtx_rtc6705.c +++ b/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)); } } } diff --git a/src/main/io/vtx_rtc6705.h b/src/main/io/vtx_rtc6705.h index 005b192c18..a16700a03f 100644 --- a/src/main/io/vtx_rtc6705.h +++ b/src/main/io/vtx_rtc6705.h @@ -25,7 +25,5 @@ #include "platform.h" -extern const char * const rtc6705PowerNames[]; - bool vtxRTC6705CanUpdate(void); bool vtxRTC6705Init(void); diff --git a/src/main/io/vtx_smartaudio.c b/src/main/io/vtx_smartaudio.c index 718bf0caa4..d0b5f797c6 100644 --- a/src/main/io/vtx_smartaudio.c +++ b/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, - SA_DEVICE_CHVAL_TO_CHANNEL(saDevice.channel) + 1); + vtxCommonLookupFrequency(&vtxSmartAudio, + SA_DEVICE_CHVAL_TO_BAND(saDevice.channel) + 1, + SA_DEVICE_CHVAL_TO_CHANNEL(saDevice.channel) + 1); return true; } diff --git a/src/main/io/vtx_smartaudio.h b/src/main/io/vtx_smartaudio.h index a0ad9ee504..7c73836632 100644 --- a/src/main/io/vtx_smartaudio.h +++ b/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; diff --git a/src/main/io/vtx_string.c b/src/main/io/vtx_string.c index c92c35d89c..9c743dd6a3 100644 --- a/src/main/io/vtx_string.c +++ b/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. -bool vtx58_Freq2Bandchan(uint16_t freq, uint8_t *pBand, uint8_t *pChannel) +const uint16_t *vtxStringFrequencyTable(void) { - // Use reverse lookup order so that 5880Mhz - // 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; + return &vtx58frequencyTable[0][0]; } -//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 vtx58_Bandchan2Freq(uint8_t band, uint8_t channel) +const char **vtxStringBandNames(void) { - if (band > 0 && band <= VTX_STRING_BAND_COUNT && - channel > 0 && channel <= VTX_STRING_CHAN_COUNT) { - return vtx58frequencyTable[band - 1][channel - 1]; - } - return 0; + return vtx58BandNames; +} + +const char **vtxStringChannelNames(void) +{ + return vtx58ChannelNames; +} + +const char *vtxStringBandLetters(void) +{ + return vtx58BandLetter; } #endif diff --git a/src/main/io/vtx_string.h b/src/main/io/vtx_string.h index 4f7fcb6655..d1ef166156 100644 --- a/src/main/io/vtx_string.h +++ b/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]; -extern const char * const vtx58BandNames[]; -extern const char * const vtx58ChannelNames[]; -extern const char vtx58BandLetter[]; - -bool vtx58_Freq2Bandchan(uint16_t freq, uint8_t *pBand, uint8_t *pChannel); -uint16_t vtx58_Bandchan2Freq(uint8_t band, uint8_t channel); +const uint16_t * vtxStringFrequencyTable(void); +const char ** vtxStringBandNames(void); +const char ** vtxStringChannelNames(void); +const char * vtxStringBandLetters(void); diff --git a/src/main/io/vtx_tramp.c b/src/main/io/vtx_tramp.c index 591bdd4b89..5dabda3c20 100644 --- a/src/main/io/vtx_tramp.c +++ b/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 diff --git a/src/main/io/vtx_tramp.h b/src/main/io/vtx_tramp.h index 8350016560..89c859da90 100644 --- a/src/main/io/vtx_tramp.h +++ b/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 diff --git a/src/main/telemetry/srxl.c b/src/main/telemetry/srxl.c index 7eae1e1a2d..e1bd5ec2ad 100644 --- a/src/main/telemetry/srxl.c +++ b/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)