diff --git a/radio/src/boards/generic_stm32/CMakeLists.txt b/radio/src/boards/generic_stm32/CMakeLists.txt
index 91ff8b993e2..a1c6e298fed 100644
--- a/radio/src/boards/generic_stm32/CMakeLists.txt
+++ b/radio/src/boards/generic_stm32/CMakeLists.txt
@@ -22,6 +22,7 @@ set(BOARD_LIB_SRC
   ${CMAKE_CURRENT_BINARY_DIR}/hal_adc_inputs.inc
 
   boards/generic_stm32/module_ports.cpp
+  boards/generic_stm32/trainer_ports.cpp
   boards/generic_stm32/aux_ports.cpp
   boards/generic_stm32/sport_update.cpp
   boards/generic_stm32/intmodule_heartbeat.cpp
diff --git a/radio/src/boards/generic_stm32/trainer_ports.cpp b/radio/src/boards/generic_stm32/trainer_ports.cpp
new file mode 100644
index 00000000000..783e9a1a198
--- /dev/null
+++ b/radio/src/boards/generic_stm32/trainer_ports.cpp
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) EdgeTX
+ *
+ * Based on code named
+ *   opentx - https://github.com/opentx/opentx
+ *   th9x - http://code.google.com/p/th9x
+ *   er9x - http://code.google.com/p/er9x
+ *   gruvin9x - http://code.google.com/p/gruvin9x
+ *
+ * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 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 for more details.
+ */
+
+#include "stm32_pulse_driver.h"
+#include "trainer_driver.h"
+
+#include "hal/module_port.h"
+#include "dataconstants.h"
+
+#include "hal.h"
+
+void board_trainer_init()
+{
+#if defined(TRAINER_DETECT_GPIO_PIN)
+  LL_GPIO_InitTypeDef pinInit;
+  LL_GPIO_StructInit(&pinInit);
+
+  pinInit.Pin = TRAINER_DETECT_GPIO_PIN;
+  pinInit.Mode = LL_GPIO_MODE_INPUT;
+  pinInit.Pull = LL_GPIO_PULL_UP;
+  LL_GPIO_Init(TRAINER_DETECT_GPIO, &pinInit);
+#endif  
+
+  trainer_init();
+}
+
+#if defined(TRAINER_GPIO)
+
+static_assert(__IS_TRAINER_TIMER_OUT_CHANNEL_SUPPORTED(TRAINER_OUT_TIMER_Channel),
+              "Unsupported trainer timer output channel");
+
+static_assert(__IS_TRAINER_TIMER_IN_CHANNEL_SUPPORTED(TRAINER_IN_TIMER_Channel),
+              "Unsupported trainer timer input channel");
+
+static const stm32_pulse_timer_t trainerOutputTimer = {
+  .GPIOx = TRAINER_GPIO,
+  .GPIO_Pin = TRAINER_OUT_GPIO_PIN,
+  .GPIO_Alternate = TRAINER_GPIO_AF,
+  .TIMx = TRAINER_TIMER,
+  .TIM_Freq = TRAINER_TIMER_FREQ,
+  .TIM_Channel = TRAINER_OUT_TIMER_Channel,
+  .TIM_IRQn = TRAINER_TIMER_IRQn,
+  .DMAx = nullptr,
+  .DMA_Stream = 0,
+  .DMA_Channel = 0,
+  .DMA_IRQn = (IRQn_Type)0,
+  .DMA_TC_CallbackPtr = nullptr,
+};
+
+void trainer_init_dsc_out()
+{
+  trainer_init_output(&trainerOutputTimer);
+}
+
+static const stm32_pulse_timer_t trainerInputTimer = {
+  .GPIOx = TRAINER_GPIO,
+  .GPIO_Pin = TRAINER_IN_GPIO_PIN,
+  .GPIO_Alternate = TRAINER_GPIO_AF,
+  .TIMx = TRAINER_TIMER,
+  .TIM_Freq = TRAINER_TIMER_FREQ,
+  .TIM_Channel = TRAINER_IN_TIMER_Channel,
+  .TIM_IRQn = TRAINER_TIMER_IRQn,
+  .DMAx = nullptr,
+  .DMA_Stream = 0,
+  .DMA_Channel = 0,
+  .DMA_IRQn = (IRQn_Type)0,
+  .DMA_TC_CallbackPtr = nullptr,
+};
+
+void trainer_init_dsc_in()
+{
+  trainer_init_capture(&trainerInputTimer);
+}
+
+void trainer_stop_dsc() { trainer_stop(); }
+
+#else
+void trainer_init_dsc_out() {}
+void trainer_init_dsc_in() {}
+void trainer_stop_dsc() {}
+#endif
+
+bool is_trainer_dsc_connected()
+{
+#if defined(TRAINER_DETECT_GPIO_PIN)
+  bool set = LL_GPIO_IsInputPinSet(TRAINER_DETECT_GPIO, TRAINER_DETECT_GPIO_PIN);
+#if defined(TRAINER_DETECT_INVERTED)
+  return !set;
+#else
+  return set;
+#endif
+#else // TRAINER_DETECT_GPIO_PIN
+  return true;
+#endif
+}
+
+void init_trainer_module_cppm()
+{
+  auto port =  modulePortFind(EXTERNAL_MODULE, ETX_MOD_TYPE_TIMER,
+                              ETX_MOD_PORT_TIMER, ETX_Pol_Normal,
+                              ETX_MOD_DIR_RX);
+  if (!port) return;
+
+  auto tim = (const stm32_pulse_timer_t*)port->hw_def;
+  if (!tim) return;
+
+  modulePortSetPower(EXTERNAL_MODULE,true);
+  trainer_init_capture(tim);
+}
+
+void stop_trainer_module_cppm()
+{
+  trainer_stop();
+  modulePortSetPower(EXTERNAL_MODULE,false);
+}
+
+#if defined(TRAINER_TIMER_IRQHandler)
+extern "C" void TRAINER_TIMER_IRQHandler() { trainer_timer_isr(); }
+#endif
+
+#if defined(TRAINER_MODULE_CPPM_TIMER_IRQHandler) && \
+  TRAINER_TIMER_IRQHandler != TRAINER_MODULE_CPPM_TIMER_IRQHandler
+extern "C" void TRAINER_MODULE_CPPM_TIMER_IRQHandler() { trainer_timer_isr(); }
+#endif
diff --git a/radio/src/hal/trainer_driver.h b/radio/src/hal/trainer_driver.h
index d11fe718c99..723312b997c 100644
--- a/radio/src/hal/trainer_driver.h
+++ b/radio/src/hal/trainer_driver.h
@@ -22,15 +22,16 @@
 #pragma once
 
 // Startup init
-void init_trainer();
+void board_trainer_init();
 
 // Output mode
-void init_trainer_ppm();
-void stop_trainer_ppm();
+void trainer_init_dsc_out();
 
 // Input mode
-void init_trainer_capture();
-void stop_trainer_capture();
+void trainer_init_dsc_in();
+
+// Stop input/output
+void trainer_stop_dsc();
 
 // Cable inserted?
 bool is_trainer_dsc_connected();
diff --git a/radio/src/myeeprom.h b/radio/src/myeeprom.h
index f68d61e0e56..f7203c61a91 100644
--- a/radio/src/myeeprom.h
+++ b/radio/src/myeeprom.h
@@ -40,12 +40,6 @@
 #define GET_MODULE_PPM_DELAY(idx)                (g_model.moduleData[idx].ppm.delay * 50 + 300)
 #define GET_TRAINER_PPM_DELAY()                  (g_model.trainerData.delay * 50 + 300)
 
-#if defined(HARDWARE_TRAINER_EXTERNAL_MODULE)
-  #define IS_TRAINER_EXTERNAL_MODULE()           (g_model.trainerData.mode == TRAINER_MODE_MASTER_SBUS_EXTERNAL_MODULE || g_model.trainerData.mode == TRAINER_MODE_MASTER_CPPM_EXTERNAL_MODULE)
-#else
-  #define IS_TRAINER_EXTERNAL_MODULE()           false
-#endif
-
 #define IS_PLAY_FUNC(func)             ((func) >= FUNC_PLAY_SOUND && func <= FUNC_PLAY_VALUE)
 
 #if defined(GVARS)
diff --git a/radio/src/targets/common/arm/stm32/trainer_driver.cpp b/radio/src/targets/common/arm/stm32/trainer_driver.cpp
index f423622d133..af78bad9ab3 100644
--- a/radio/src/targets/common/arm/stm32/trainer_driver.cpp
+++ b/radio/src/targets/common/arm/stm32/trainer_driver.cpp
@@ -29,44 +29,11 @@
 
 #include "opentx.h"
 
-#define __IS_TRAINER_TIMER_OUT_CHANNEL_SUPPORTED(ch)             \
-  (((ch) == LL_TIM_CHANNEL_CH1 || (ch) == LL_TIM_CHANNEL_CH2 ||  \
-    (ch) == LL_TIM_CHANNEL_CH3 || (ch) == LL_TIM_CHANNEL_CH4) && \
-   __STM32_PULSE_IS_TIMER_CHANNEL_SUPPORTED(ch))
-
-#define __IS_TRAINER_TIMER_IN_CHANNEL_SUPPORTED(ch)            \
-  ((ch) == LL_TIM_CHANNEL_CH1 || (ch) == LL_TIM_CHANNEL_CH2 || \
-   (ch) == LL_TIM_CHANNEL_CH3 || (ch) == LL_TIM_CHANNEL_CH4)
-
-#if defined(TRAINER_GPIO)
-
-static_assert(__IS_TRAINER_TIMER_OUT_CHANNEL_SUPPORTED(TRAINER_OUT_TIMER_Channel),
-              "Unsupported trainer timer output channel");
-
-static_assert(__IS_TRAINER_TIMER_IN_CHANNEL_SUPPORTED(TRAINER_IN_TIMER_Channel),
-              "Unsupported trainer timer input channel");
-#else
-void init_trainer_ppm() {}
-void stop_trainer_ppm() {}
-void init_trainer_capture() {}
-void stop_trainer_capture() {}
-#endif
-
 static void (*_trainer_timer_isr)();
 static const stm32_pulse_timer_t* _trainer_timer;
 
-void init_trainer()
+void trainer_init()
 {
-#if defined(TRAINER_DETECT_GPIO_PIN)
-  LL_GPIO_InitTypeDef pinInit;
-  LL_GPIO_StructInit(&pinInit);
-
-  pinInit.Pin = TRAINER_DETECT_GPIO_PIN;
-  pinInit.Mode = LL_GPIO_MODE_INPUT;
-  pinInit.Pull = LL_GPIO_PULL_UP;
-  LL_GPIO_Init(TRAINER_DETECT_GPIO, &pinInit);
-#endif  
-
   _trainer_timer = nullptr;
   _trainer_timer_isr = nullptr;
 }
@@ -134,14 +101,14 @@ static void trainer_in_isr()
   captureTrainerPulses(capture);
 }
 
-static void _stop_trainer(const stm32_pulse_timer_t* tim)
+void trainer_stop()
 {
-  stm32_pulse_deinit(tim);
+  stm32_pulse_deinit(_trainer_timer);
   _trainer_timer_isr = nullptr;
   _trainer_timer = nullptr;
 }
 
-static void _init_trainer_capture(const stm32_pulse_timer_t* tim)
+void trainer_init_capture(const stm32_pulse_timer_t* tim)
 {
   // set proper ISR handler first
   _trainer_timer = tim;
@@ -168,44 +135,27 @@ static void _init_trainer_capture(const stm32_pulse_timer_t* tim)
   LL_TIM_EnableCounter(tim->TIMx);
 }
 
-#if defined(TRAINER_GPIO)
-
-static const stm32_pulse_timer_t trainerOutputTimer = {
-  .GPIOx = TRAINER_GPIO,
-  .GPIO_Pin = TRAINER_OUT_GPIO_PIN,
-  .GPIO_Alternate = TRAINER_GPIO_AF,
-  .TIMx = TRAINER_TIMER,
-  .TIM_Freq = TRAINER_TIMER_FREQ,
-  .TIM_Channel = TRAINER_OUT_TIMER_Channel,
-  .TIM_IRQn = TRAINER_TIMER_IRQn,
-  .DMAx = nullptr,
-  .DMA_Stream = 0,
-  .DMA_Channel = 0,
-  .DMA_IRQn = (IRQn_Type)0,
-  .DMA_TC_CallbackPtr = nullptr,
-};
-
-static void trainerSendNextFrame()
+static void trainer_send_next_frame(const stm32_pulse_timer_t* tim)
 {
-  stm32_pulse_set_polarity(&trainerOutputTimer, GET_TRAINER_PPM_POLARITY());
-  stm32_pulse_set_cmp_val(&trainerOutputTimer, GET_TRAINER_PPM_DELAY() * 2);
+  stm32_pulse_set_polarity(tim, GET_TRAINER_PPM_POLARITY());
+  stm32_pulse_set_cmp_val(tim, GET_TRAINER_PPM_DELAY() * 2);
   
   // load the first period: next reload when CC compare event triggers
   trainerPulsesData.ppm.ptr = trainerPulsesData.ppm.pulses;
   TRAINER_TIMER->ARR = *(trainerPulsesData.ppm.ptr++);
 
-  switch (trainerOutputTimer.TIM_Channel) {
+  switch (tim->TIM_Channel) {
   case LL_TIM_CHANNEL_CH1:
-    LL_TIM_EnableIT_CC1(trainerOutputTimer.TIMx);
+    LL_TIM_EnableIT_CC1(tim->TIMx);
     break;
   case LL_TIM_CHANNEL_CH2:
-    LL_TIM_EnableIT_CC2(trainerOutputTimer.TIMx);
+    LL_TIM_EnableIT_CC2(tim->TIMx);
     break;
   case LL_TIM_CHANNEL_CH3:
-    LL_TIM_EnableIT_CC3(trainerOutputTimer.TIMx);
+    LL_TIM_EnableIT_CC3(tim->TIMx);
     break;
   case LL_TIM_CHANNEL_CH4:
-    LL_TIM_EnableIT_CC4(trainerOutputTimer.TIMx);
+    LL_TIM_EnableIT_CC4(tim->TIMx);
     break;
   }
 }
@@ -223,130 +173,29 @@ static void trainer_out_isr()
                          *(trainerPulsesData.ppm.ptr++));
   } else {
     setupPulsesPPMTrainer();
-    trainerSendNextFrame();
+    trainer_send_next_frame(_trainer_timer);
   }  
 }
 
-void init_trainer_ppm()
+void trainer_init_output(const stm32_pulse_timer_t* tim)
 {
   // set proper ISR handler first
-  _trainer_timer = &trainerOutputTimer;
+  _trainer_timer = tim;
   _trainer_timer_isr = trainer_out_isr;
 
-  stm32_pulse_init(&trainerOutputTimer, 0);
-  stm32_pulse_config_output(&trainerOutputTimer, GET_TRAINER_PPM_POLARITY(),
+  stm32_pulse_init(_trainer_timer, 0);
+  stm32_pulse_config_output(_trainer_timer, GET_TRAINER_PPM_POLARITY(),
                             LL_TIM_OCMODE_PWM1, GET_TRAINER_PPM_DELAY() * 2);
 
   setupPulsesPPMTrainer();
-  trainerSendNextFrame();
-
-  LL_TIM_EnableCounter(trainerOutputTimer.TIMx);
-}
-
-void stop_trainer_ppm()
-{
-  _stop_trainer(&trainerOutputTimer);
-}
-
-static const stm32_pulse_timer_t trainerInputTimer = {
-  .GPIOx = TRAINER_GPIO,
-  .GPIO_Pin = TRAINER_IN_GPIO_PIN,
-  .GPIO_Alternate = TRAINER_GPIO_AF,
-  .TIMx = TRAINER_TIMER,
-  .TIM_Freq = TRAINER_TIMER_FREQ,
-  .TIM_Channel = TRAINER_IN_TIMER_Channel,
-  .TIM_IRQn = TRAINER_TIMER_IRQn,
-  .DMAx = nullptr,
-  .DMA_Stream = 0,
-  .DMA_Channel = 0,
-  .DMA_IRQn = (IRQn_Type)0,
-  .DMA_TC_CallbackPtr = nullptr,
-};
+  trainer_send_next_frame(_trainer_timer);
 
-void init_trainer_capture()
-{
-  _init_trainer_capture(&trainerInputTimer);
+  LL_TIM_EnableCounter(_trainer_timer->TIMx);
 }
 
-void stop_trainer_capture()
+void trainer_timer_isr()
 {
-  _stop_trainer(&trainerInputTimer);
-}
-
-#endif // TRAINER_GPIO
-
-bool is_trainer_dsc_connected()
-{
-#if defined(TRAINER_DETECT_GPIO_PIN)
-  bool set = LL_GPIO_IsInputPinSet(TRAINER_DETECT_GPIO, TRAINER_DETECT_GPIO_PIN);
-#if defined(TRAINER_DETECT_INVERTED)
-  return !set;
-#else
-  return set;
-#endif
-#else // TRAINER_DETECT_GPIO_PIN
-  return true;
-#endif
-}
-
-#if defined(TRAINER_GPIO) || (defined(TRAINER_MODULE_CPPM) && \
-                              !defined(TRAINER_MODULE_CPPM_TIMER_IRQHandler))
-
-#if !defined(TRAINER_TIMER_IRQHandler)
-  #error "Missing TRAINER_TIMER_IRQHandler definition"
-#endif
-
-extern "C" void TRAINER_TIMER_IRQHandler()
-{
-  DEBUG_INTERRUPT(INT_TRAINER);
-
-  if (_trainer_timer && _trainer_timer_isr)
-    _trainer_timer_isr();
-}
-#endif
-
-#if defined(TRAINER_MODULE_CPPM)
-
-#include "hal/module_port.h"
-
-static_assert(__IS_TRAINER_TIMER_IN_CHANNEL_SUPPORTED(TRAINER_MODULE_CPPM_TIMER_Channel),
-              "Unsupported trainer timer input channel");
-
-static const stm32_pulse_timer_t trainerModuleTimer = {
-  .GPIOx = TRAINER_MODULE_CPPM_GPIO,
-  .GPIO_Pin = TRAINER_MODULE_CPPM_GPIO_PIN,
-  .GPIO_Alternate = TRAINER_MODULE_CPPM_GPIO_AF,
-  .TIMx = TRAINER_MODULE_CPPM_TIMER,
-  .TIM_Freq = TRAINER_MODULE_CPPM_FREQ,
-  .TIM_Channel = TRAINER_MODULE_CPPM_TIMER_Channel,
-  .TIM_IRQn = TRAINER_MODULE_CPPM_TIMER_IRQn,
-  .DMAx = nullptr,
-  .DMA_Stream = 0,
-  .DMA_Channel = 0,
-  .DMA_IRQn = (IRQn_Type)0,
-  .DMA_TC_CallbackPtr = nullptr,
-};
-
-void init_trainer_module_cppm()
-{
-  modulePortSetPower(EXTERNAL_MODULE,true);
-  _init_trainer_capture(&trainerModuleTimer);
-}
-
-void stop_trainer_module_cppm()
-{
-  _stop_trainer(&trainerModuleTimer);
-  modulePortSetPower(EXTERNAL_MODULE,false);
-}
-
-#if defined(TRAINER_MODULE_CPPM_TIMER_IRQHandler)
-extern "C" void TRAINER_MODULE_CPPM_TIMER_IRQHandler()
-{
-  DEBUG_INTERRUPT(INT_TRAINER);
-
   if (_trainer_timer && _trainer_timer_isr)
     _trainer_timer_isr();
 }
-#endif
 
-#endif // TRAINER_MODULE_CPPM
diff --git a/radio/src/targets/common/arm/stm32/trainer_driver.h b/radio/src/targets/common/arm/stm32/trainer_driver.h
new file mode 100644
index 00000000000..613bbc784c8
--- /dev/null
+++ b/radio/src/targets/common/arm/stm32/trainer_driver.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) EdgeTX
+ *
+ * Based on code named
+ *   opentx - https://github.com/opentx/opentx
+ *   th9x - http://code.google.com/p/th9x
+ *   er9x - http://code.google.com/p/er9x
+ *   gruvin9x - http://code.google.com/p/gruvin9x
+ *
+ * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 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 for more details.
+ */
+
+#pragma once
+
+#define __IS_TRAINER_TIMER_OUT_CHANNEL_SUPPORTED(ch)             \
+  (((ch) == LL_TIM_CHANNEL_CH1 || (ch) == LL_TIM_CHANNEL_CH2 ||  \
+    (ch) == LL_TIM_CHANNEL_CH3 || (ch) == LL_TIM_CHANNEL_CH4) && \
+   __STM32_PULSE_IS_TIMER_CHANNEL_SUPPORTED(ch))
+
+#define __IS_TRAINER_TIMER_IN_CHANNEL_SUPPORTED(ch)            \
+  ((ch) == LL_TIM_CHANNEL_CH1 || (ch) == LL_TIM_CHANNEL_CH2 || \
+   (ch) == LL_TIM_CHANNEL_CH3 || (ch) == LL_TIM_CHANNEL_CH4)
+
+struct stm32_pulse_timer_t;
+
+void trainer_init();
+void trainer_init_capture(const stm32_pulse_timer_t* tim);
+void trainer_init_output(const stm32_pulse_timer_t* tim);
+void trainer_stop();
+
+// Call this from the timer's IRQ
+void trainer_timer_isr();
diff --git a/radio/src/targets/horus/board.cpp b/radio/src/targets/horus/board.cpp
index 23a22836ab6..a310426494e 100644
--- a/radio/src/targets/horus/board.cpp
+++ b/radio/src/targets/horus/board.cpp
@@ -139,7 +139,7 @@ void boardInit()
   pulsesSetModuleDeInitCb(_intmodule_heartbeat_deinit);
 #endif
 
-  init_trainer();
+  board_trainer_init();
   pwrOn();
   delaysInit();
 
diff --git a/radio/src/targets/nv14/board.cpp b/radio/src/targets/nv14/board.cpp
index 67522258f28..d5143d9b7f1 100644
--- a/radio/src/targets/nv14/board.cpp
+++ b/radio/src/targets/nv14/board.cpp
@@ -221,7 +221,7 @@ void boardInit()
   pwrInit();
   boardInitModulePorts();
 
-  init_trainer();
+  board_trainer_init();
   battery_charge_init();
   flysky_gimbal_init();
   timersInit();
diff --git a/radio/src/targets/simu/module_drivers.cpp b/radio/src/targets/simu/module_drivers.cpp
index b75c8211a50..6af8ff7d76d 100644
--- a/radio/src/targets/simu/module_drivers.cpp
+++ b/radio/src/targets/simu/module_drivers.cpp
@@ -45,10 +45,9 @@ void extmoduleSendNextFramePxx1(void const*, unsigned short) {}
 void extmoduleSendNextFrameSoftSerial(void const*, unsigned short, bool) {}
 void extmoduleSendNextFramePpm(void*, unsigned short, unsigned short, bool) {}
 
-void init_trainer_ppm() {}
-void stop_trainer_ppm() {}
-void init_trainer_capture() {}
-void stop_trainer_capture() {}
+void trainer_init_dsc_out() {}
+void trainer_init_dsc_in() {}
+void trainer_stop_dsc() {}
 
 bool is_trainer_dsc_connected() { return false; }
 
diff --git a/radio/src/targets/taranis/board.cpp b/radio/src/targets/taranis/board.cpp
index 228b0ccf2f0..11e689d11cc 100644
--- a/radio/src/targets/taranis/board.cpp
+++ b/radio/src/targets/taranis/board.cpp
@@ -136,7 +136,8 @@ void boardInit()
   }
 #endif
 
-  init_trainer();
+  board_trainer_init();
+
   // Sets 'hardwareOption.pcbrev' as well
   pwrInit();
   boardInitModulePorts();
diff --git a/radio/src/targets/taranis/hal.h b/radio/src/targets/taranis/hal.h
index 7f3e81ed37f..e97d7a45395 100644
--- a/radio/src/targets/taranis/hal.h
+++ b/radio/src/targets/taranis/hal.h
@@ -2033,7 +2033,6 @@
 #endif
 
 // Trainer Port
-#define HARDWARE_TRAINER_EXTERNAL_MODULE
 #if defined(PCBXLITES) || defined(PCBX9LITE)
   // on these 2 radios the trainer port already uses DMA1_Stream6, we won't use the DMA
   #define TRAINER_RCC_AHB1Periph        RCC_AHB1Periph_GPIOD
diff --git a/radio/src/tests/module_ports.cpp b/radio/src/tests/module_ports.cpp
index 9302d5961d6..5a6ebdc5bfe 100644
--- a/radio/src/tests/module_ports.cpp
+++ b/radio/src/tests/module_ports.cpp
@@ -22,6 +22,7 @@
 #include "gtests.h"
 #include "hal/module_driver.h"
 #include "hal/module_port.h"
+#include "hal/serial_driver.h"
 #include "pulses/modules_constants.h"
 #include "pulses/pulses.h"
 #include "translations.h"
@@ -38,7 +39,8 @@ TEST(ports, softserialFallback)
   };
 
   bool has_softserial = modulePortFind(EXTERNAL_MODULE, ETX_MOD_TYPE_SERIAL,
-				       ETX_MOD_PORT_SPORT_INV, ETX_Pol_Inverted);
+                                       ETX_MOD_PORT_SPORT_INV, ETX_Pol_Inverted,
+                                       ETX_Dir_RX);
   if (has_softserial) {
     auto mod_st = modulePortInitSerial(EXTERNAL_MODULE, ETX_MOD_PORT_SPORT,
                                        &serialCfg, false);
diff --git a/radio/src/trainer.cpp b/radio/src/trainer.cpp
index 6be72ffa780..81d84dabd3e 100644
--- a/radio/src/trainer.cpp
+++ b/radio/src/trainer.cpp
@@ -75,11 +75,8 @@ void stopTrainer()
 {
   switch (currentTrainerMode) {
     case TRAINER_MODE_MASTER_TRAINER_JACK:
-      stop_trainer_capture();
-      break;
-
     case TRAINER_MODE_SLAVE:
-      stop_trainer_ppm();
+      trainer_stop_dsc();
       break;
 
 #if defined(SBUS_TRAINER)
@@ -94,12 +91,10 @@ void stopTrainer()
       break;
 #endif
 
-#if defined(TRAINER_MODULE_SBUS)
     case TRAINER_MODE_MASTER_SBUS_EXTERNAL_MODULE:
       sbusSetGetByte(nullptr);
       stop_trainer_module_sbus();
       break;
-#endif
   }
 
 #if defined(INTMODULE_HEARTBEAT_GPIO) && !defined(SIMU) && \
@@ -127,11 +122,11 @@ void checkTrainerSettings()
 
     switch (requiredTrainerMode) {
       case TRAINER_MODE_MASTER_TRAINER_JACK:
-        init_trainer_capture();
+        trainer_init_dsc_in();
         break;
 
       case TRAINER_MODE_SLAVE:
-        init_trainer_ppm();
+        trainer_init_dsc_out();
         break;
 
 #if defined(SBUS_TRAINER)
@@ -174,10 +169,13 @@ static etx_module_state_t* sbus_trainer_mod_st = nullptr;
 static void init_trainer_module_sbus()
 {
   if (sbus_trainer_mod_st) return;
-  modulePortSetPower(EXTERNAL_MODULE,true);
 
   sbus_trainer_mod_st = modulePortInitSerial(EXTERNAL_MODULE, ETX_MOD_PORT_UART,
                                              &sbusTrainerParams, false);
+
+  if (sbus_trainer_mod_st) {
+    modulePortSetPower(EXTERNAL_MODULE,true);
+  }
 }
 
 static void stop_trainer_module_sbus()