src/platform/STM32/transponder_ir_io_hal.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 #include "platform.h"
  26
  27 #ifdef USE_TRANSPONDER
  28
  29 #include "drivers/dma.h"
  30 #include "drivers/dma_reqmap.h"
  31 #include "drivers/io.h"
  32 #include "drivers/nvic.h"
  33 #include "drivers/rcc.h"
  34 #include "drivers/timer.h"
  35 #include "drivers/transponder_ir_arcitimer.h"
  36 #include "drivers/transponder_ir_erlt.h"
  37 #include "drivers/transponder_ir_ilap.h"
  38
  39 #include "drivers/transponder_ir.h"
  40
  41 volatile uint8_t transponderIrDataTransferInProgress = 0;
  42
  43 static IO_t transponderIO = IO_NONE;
  44 static TIM_HandleTypeDef TimHandle;
  45 static uint16_t timerChannel = 0;
  46 static uint8_t output;
  47 static uint8_t alternateFunction;
  48
  49 #if !(defined(STM32F7) || defined(STM32H7) || defined(STM32G4))
  50 #error "Transponder (via HAL) not supported on this MCU."
  51 #endif
  52
  53 #if defined(STM32H7)
  54 DMA_RAM transponder_t transponder;
  55 #elif defined(STM32G4)
  56 DMA_RAM_W transponder_t transponder;
  57 #else
  58 transponder_t transponder;
  59 #endif
  60 bool transponderInitialised = false;
  61
  62 FAST_IRQ_HANDLER static void TRANSPONDER_DMA_IRQHandler(dmaChannelDescriptor_t* descriptor)
  63 {
  64     HAL_DMA_IRQHandler(TimHandle.hdma[descriptor->userParam]);
  65     TIM_DMACmd(&TimHandle, timerChannel, DISABLE);
  66     transponderIrDataTransferInProgress = 0;
  67 }
  68
  69 void transponderIrHardwareInit(ioTag_t ioTag, transponder_t *transponder)
  70 {
  71     if (!ioTag) {
  72         return;
  73     }
  74
  75     const timerHardware_t *timerHardware = timerAllocate(ioTag, OWNER_TRANSPONDER, 0);
  76     TIM_TypeDef *timer = timerHardware->tim;
  77     timerChannel = timerHardware->channel;
  78     output = timerHardware->output;
  79     alternateFunction = timerHardware->alternateFunction;
  80
  81 #if defined(USE_DMA_SPEC)
  82     const dmaChannelSpec_t *dmaSpec = dmaGetChannelSpecByTimer(timerHardware);
  83
  84     if (dmaSpec == NULL) {
  85         return;
  86     }
  87
  88     dmaResource_t *dmaRef = dmaSpec->ref;
  89     uint32_t dmaChannel = dmaSpec->channel;
  90 #else
  91     dmaResource_t *dmaRef = timerHardware->dmaRef;
  92     uint32_t dmaChannel = timerHardware->dmaChannel;
  93 #endif
  94
  95     dmaIdentifier_e dmaIdentifier = dmaGetIdentifier(dmaRef);
  96     if (dmaRef == NULL || !dmaAllocate(dmaIdentifier, OWNER_TRANSPONDER, 0)) {
  97         return;
  98     }
  99
 100     /* Time base configuration */
 101
 102     TimHandle.Instance = timer;
 103
 104     uint16_t prescaler = timerGetPrescalerByDesiredMhz(timer, transponder->timer_hz);
 105     uint16_t period = timerGetPeriodByPrescaler(timer, prescaler, transponder->timer_carrier_hz);
 106
 107     transponder->bitToggleOne = period / 2;
 108
 109     TimHandle.Init.Prescaler = prescaler;
 110     TimHandle.Init.Period = period; // 800kHz
 111     TimHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
 112     TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
 113     if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK) {
 114         /* Initialization Error */
 115         return;
 116     }
 117
 118     /* IO configuration */
 119
 120     static DMA_HandleTypeDef hdma_tim;
 121
 122     transponderIO = IOGetByTag(ioTag);
 123     IOInit(transponderIO, OWNER_TRANSPONDER, 0);
 124     IOConfigGPIOAF(transponderIO, IO_CONFIG(GPIO_MODE_AF_PP, GPIO_SPEED_FREQ_VERY_HIGH, GPIO_PULLDOWN), timerHardware->alternateFunction);
 125
 126     __DMA1_CLK_ENABLE();
 127     __DMA2_CLK_ENABLE();
 128
 129     /* Set the parameters to be configured */
 130 #if defined(STM32H7) || defined(STM32G4)
 131     hdma_tim.Init.Request = dmaChannel;
 132 #else
 133     hdma_tim.Init.Channel = dmaChannel;
 134 #endif
 135     hdma_tim.Init.Direction = DMA_MEMORY_TO_PERIPH;
 136     hdma_tim.Init.PeriphInc = DMA_PINC_DISABLE;
 137     hdma_tim.Init.MemInc = DMA_MINC_ENABLE;
 138     hdma_tim.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
 139     hdma_tim.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
 140     hdma_tim.Init.Mode = DMA_NORMAL;
 141     hdma_tim.Init.Priority = DMA_PRIORITY_HIGH;
 142 #if !defined(STM32G4)
 143     hdma_tim.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
 144     hdma_tim.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
 145     hdma_tim.Init.MemBurst = DMA_MBURST_SINGLE;
 146     hdma_tim.Init.PeriphBurst = DMA_PBURST_SINGLE;
 147 #endif
 148
 149     /* Set hdma_tim instance */
 150     hdma_tim.Instance = (DMA_ARCH_TYPE *)dmaRef;
 151
 152     uint16_t dmaIndex = timerDmaIndex(timerChannel);
 153
 154     /* Link hdma_tim to hdma[x] (channelx) */
 155     __HAL_LINKDMA(&TimHandle, hdma[dmaIndex], hdma_tim);
 156
 157     dmaEnable(dmaIdentifier);
 158     dmaSetHandler(dmaIdentifier, TRANSPONDER_DMA_IRQHandler, NVIC_PRIO_TRANSPONDER_DMA, dmaIndex);
 159
 160     /* Initialize TIMx DMA handle */
 161     if (HAL_DMA_Init(TimHandle.hdma[dmaIndex]) != HAL_OK) {
 162         /* Initialization Error */
 163         return;
 164     }
 165
 166     RCC_ClockCmd(timerRCC(timer), ENABLE);
 167
 168     /* PWM1 Mode configuration: Channel1 */
 169     TIM_OC_InitTypeDef  TIM_OCInitStructure;
 170
 171     TIM_OCInitStructure.OCMode = TIM_OCMODE_PWM1;
 172     TIM_OCInitStructure.OCIdleState = TIM_OCIDLESTATE_RESET;
 173     TIM_OCInitStructure.OCPolarity = (timerHardware->output & TIMER_OUTPUT_INVERTED) ? TIM_OCPOLARITY_LOW : TIM_OCPOLARITY_HIGH;
 174     TIM_OCInitStructure.OCNIdleState = TIM_OCNIDLESTATE_RESET;
 175     TIM_OCInitStructure.OCNPolarity = (timerHardware->output & TIMER_OUTPUT_INVERTED) ? TIM_OCNPOLARITY_LOW : TIM_OCNPOLARITY_HIGH;
 176     TIM_OCInitStructure.Pulse = 0;
 177     TIM_OCInitStructure.OCFastMode = TIM_OCFAST_DISABLE;
 178     if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &TIM_OCInitStructure, timerChannel) != HAL_OK) {
 179         /* Configuration Error */
 180         return;
 181     }
 182     if (timerHardware->output & TIMER_OUTPUT_N_CHANNEL) {
 183         if (HAL_TIMEx_PWMN_Start(&TimHandle, timerChannel) != HAL_OK) {
 184             /* Starting PWM generation Error */
 185             return;
 186         }
 187     } else {
 188         if (HAL_TIM_PWM_Start(&TimHandle, timerChannel) != HAL_OK) {
 189             /* Starting PWM generation Error */
 190             return;
 191         }
 192     }
 193
 194     transponderInitialised = true;
 195 }
 196
 197 bool transponderIrInit(const ioTag_t ioTag, const transponderProvider_e provider)
 198 {
 199     if (!ioTag) {
 200         return false;
 201     }
 202
 203     switch (provider) {
 204         case TRANSPONDER_ARCITIMER:
 205             transponderIrInitArcitimer(&transponder);
 206             break;
 207         case TRANSPONDER_ILAP:
 208             transponderIrInitIlap(&transponder);
 209             break;
 210         case TRANSPONDER_ERLT:
 211             transponderIrInitERLT(&transponder);
 212             break;
 213         default:
 214             return false;
 215     }
 216
 217     transponderIrHardwareInit(ioTag, &transponder);
 218
 219     return true;
 220 }
 221
 222 bool isTransponderIrReady(void)
 223 {
 224     return !transponderIrDataTransferInProgress;
 225 }
 226
 227 void transponderIrWaitForTransmitComplete(void)
 228 {
 229 #ifdef DEBUG
 230     static uint32_t waitCounter = 0;
 231 #endif
 232
 233     while (transponderIrDataTransferInProgress) {
 234 #ifdef DEBUG
 235         waitCounter++;
 236 #endif
 237     }
 238 }
 239
 240 void transponderIrUpdateData(const uint8_t* transponderData)
 241 {
 242      transponderIrWaitForTransmitComplete();
 243      transponder.vTable->updateTransponderDMABuffer(&transponder, transponderData);
 244 }
 245
 246 void transponderIrDMAEnable(transponder_t *transponder)
 247 {
 248     if (!transponderInitialised) {
 249         return;
 250     }
 251
 252     if (DMA_SetCurrDataCounter(&TimHandle, timerChannel, transponder->transponderIrDMABuffer.ilap, transponder->dma_buffer_size) != HAL_OK) {
 253         /* DMA set error */
 254         transponderIrDataTransferInProgress = 0;
 255         return;
 256     }
 257
 258     /* Reset timer counter */
 259     __HAL_TIM_SET_COUNTER(&TimHandle, 0);
 260     /* Enable channel DMA requests */
 261     TIM_DMACmd(&TimHandle, timerChannel, ENABLE);
 262 }
 263
 264 void transponderIrDisable(void)
 265 {
 266     if (!transponderInitialised) {
 267         return;
 268     }
 269
 270     TIM_DMACmd(&TimHandle, timerChannel, DISABLE);
 271     if (output & TIMER_OUTPUT_N_CHANNEL) {
 272         HAL_TIMEx_PWMN_Stop(&TimHandle, timerChannel);
 273     } else {
 274         HAL_TIM_PWM_Stop(&TimHandle, timerChannel);
 275     }
 276
 277     IOInit(transponderIO, OWNER_TRANSPONDER, 0);
 278
 279 #ifdef TRANSPONDER_INVERTED
 280     IOHi(transponderIO);
 281 #else
 282     IOLo(transponderIO);
 283 #endif
 284
 285     IOConfigGPIOAF(transponderIO, IO_CONFIG(GPIO_MODE_AF_PP, GPIO_SPEED_FREQ_VERY_HIGH, GPIO_PULLDOWN), alternateFunction);
 286 }
 287
 288 void transponderIrTransmit(void)
 289 {
 290     transponderIrWaitForTransmitComplete();
 291
 292     transponderIrDataTransferInProgress = 1;
 293     transponderIrDMAEnable(&transponder);
 294 }
 295 #endif