src/main/drivers/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 "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
 167     RCC_ClockCmd(timerRCC(timer), ENABLE);
 168
 169     /* PWM1 Mode configuration: Channel1 */
 170     TIM_OC_InitTypeDef  TIM_OCInitStructure;
 171
 172     TIM_OCInitStructure.OCMode = TIM_OCMODE_PWM1;
 173     TIM_OCInitStructure.OCIdleState = TIM_OCIDLESTATE_RESET;
 174     TIM_OCInitStructure.OCPolarity = (timerHardware->output & TIMER_OUTPUT_INVERTED) ? TIM_OCPOLARITY_LOW : TIM_OCPOLARITY_HIGH;
 175     TIM_OCInitStructure.OCNIdleState = TIM_OCNIDLESTATE_RESET;
 176     TIM_OCInitStructure.OCNPolarity = (timerHardware->output & TIMER_OUTPUT_INVERTED) ? TIM_OCNPOLARITY_LOW : TIM_OCNPOLARITY_HIGH;
 177     TIM_OCInitStructure.Pulse = 0;
 178     TIM_OCInitStructure.OCFastMode = TIM_OCFAST_DISABLE;
 179     if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &TIM_OCInitStructure, timerChannel) != HAL_OK) {
 180         /* Configuration Error */
 181         return;
 182     }
 183     if (timerHardware->output & TIMER_OUTPUT_N_CHANNEL) {
 184         if (HAL_TIMEx_PWMN_Start(&TimHandle, timerChannel) != HAL_OK) {
 185             /* Starting PWM generation Error */
 186             return;
 187         }
 188     } else {
 189         if (HAL_TIM_PWM_Start(&TimHandle, timerChannel) != HAL_OK) {
 190             /* Starting PWM generation Error */
 191             return;
 192         }
 193     }
 194
 195     transponderInitialised = true;
 196 }
 197
 198 bool transponderIrInit(const ioTag_t ioTag, const transponderProvider_e provider)
 199 {
 200     if (!ioTag) {
 201         return false;
 202     }
 203
 204     switch (provider) {
 205         case TRANSPONDER_ARCITIMER:
 206             transponderIrInitArcitimer(&transponder);
 207             break;
 208         case TRANSPONDER_ILAP:
 209             transponderIrInitIlap(&transponder);
 210             break;
 211         case TRANSPONDER_ERLT:
 212             transponderIrInitERLT(&transponder);
 213             break;
 214         default:
 215             return false;
 216     }
 217
 218     transponderIrHardwareInit(ioTag, &transponder);
 219
 220     return true;
 221 }
 222
 223 bool isTransponderIrReady(void)
 224 {
 225     return !transponderIrDataTransferInProgress;
 226 }
 227
 228 void transponderIrWaitForTransmitComplete(void)
 229 {
 230 #ifdef DEBUG
 231     static uint32_t waitCounter = 0;
 232 #endif
 233
 234     while (transponderIrDataTransferInProgress) {
 235 #ifdef DEBUG
 236         waitCounter++;
 237 #endif
 238     }
 239 }
 240
 241 void transponderIrUpdateData(const uint8_t* transponderData)
 242 {
 243      transponderIrWaitForTransmitComplete();
 244      transponder.vTable->updateTransponderDMABuffer(&transponder, transponderData);
 245 }
 246
 247 void transponderIrDMAEnable(transponder_t *transponder)
 248 {
 249     if (!transponderInitialised) {
 250         return;
 251     }
 252
 253     if (DMA_SetCurrDataCounter(&TimHandle, timerChannel, transponder->transponderIrDMABuffer.ilap, transponder->dma_buffer_size) != HAL_OK) {
 254         /* DMA set error */
 255         transponderIrDataTransferInProgress = 0;
 256         return;
 257     }
 258
 259     /* Reset timer counter */
 260     __HAL_TIM_SET_COUNTER(&TimHandle, 0);
 261     /* Enable channel DMA requests */
 262     TIM_DMACmd(&TimHandle, timerChannel, ENABLE);
 263 }
 264
 265 void transponderIrDisable(void)
 266 {
 267     if (!transponderInitialised) {
 268         return;
 269     }
 270
 271     TIM_DMACmd(&TimHandle, timerChannel, DISABLE);
 272     if (output & TIMER_OUTPUT_N_CHANNEL) {
 273         HAL_TIMEx_PWMN_Stop(&TimHandle, timerChannel);
 274     } else {
 275         HAL_TIM_PWM_Stop(&TimHandle, timerChannel);
 276     }
 277
 278
 279     IOInit(transponderIO, OWNER_TRANSPONDER, 0);
 280
 281 #ifdef TRANSPONDER_INVERTED
 282     IOHi(transponderIO);
 283 #else
 284     IOLo(transponderIO);
 285 #endif
 286
 287     IOConfigGPIOAF(transponderIO, IO_CONFIG(GPIO_MODE_AF_PP, GPIO_SPEED_FREQ_VERY_HIGH, GPIO_PULLDOWN), alternateFunction);
 288 }
 289
 290 void transponderIrTransmit(void)
 291 {
 292     transponderIrWaitForTransmitComplete();
 293
 294     transponderIrDataTransferInProgress = 1;
 295     transponderIrDMAEnable(&transponder);
 296 }
 297 #endif