[参考译文] CC1312R7：PWM 计时器间隔匹配重载异常行为

尊敬的 Marie：

您给我的链接是 CC1312R、我的工程是 CC1312R7。 CC1312R7 的勘误表未列出 GPTimer 的问题。 实际上、CC1312R 勘误表中提到的这个 GPTimer 问题是否也被视为对 CC1312R7 有效、如果是、勘误表说明中的主器件含义是什么？

此致、

Dimitar

尊敬的 Dimitar：

我将根据您的当前方法查找问题、但我也可以建议其他解决方案。 下述命令使用该计时器、与 DMA 配合使用：

/*
 * Copyright (c) 2015-2019, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 *  ======== empty.c ========
 */

/* For usleep() */
#include <unistd.h>
#include <stdint.h>
#include <stddef.h>

/* Driver Header files */
#include <ti/drivers/GPIO.h>
#include <ti/drivers/PWM.h>
#include <ti/drivers/timer/GPTimerCC26XX.h>
#include <ti/drivers/dma/UDMACC26XX.h>
// #include <ti/drivers/I2C.h>
// #include <ti/drivers/SPI.h>
// #include <ti/drivers/Watchdog.h>

/* Driver configuration */
#include "ti_drivers_config.h"

#define CONFIG_GPIO_PWM_0 6

ALLOCATE_CONTROL_TABLE_ENTRY(dmaGPT0APriControlTableEntry, UDMA_CHAN_TIMER0_A);

UDMACC26XX_Handle dmaHandle;

//assume duty cycle period = 100 (count)
uint16_t myPwmDutyInCounts[6] = {

    80,    /* 20% duty */
    70,    /* 30% duty */
    60,   /* 40% duty */
    50,   /* 50% duty */
    40,   /* 60% duty */
    100,   /* stop */
};

/*
 *  ======== mainThread ========
 */
void *mainThread(void *arg0)
{
    /* 1 second delay */
    uint32_t time = 1;

    /* Call driver init functions */
    GPIO_init();
    PWM_init();
    dmaHandle = UDMACC26XX_open();


    /* Configure the PWM pin */
    GPIO_setConfig(CONFIG_GPIO_PWM_0, GPIO_CFG_OUTPUT_INTERNAL | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW);

    /* Initialize the PWM parameters */
    PWM_Params pwmParams;
    PWM_Params_init(&pwmParams);
    pwmParams.idleLevel = PWM_IDLE_LOW;         /* Output low when PWM is not running */
    pwmParams.periodUnits = PWM_PERIOD_COUNTS;  /* Period is in counts */
    pwmParams.periodValue = 1;                  /* 0 MHz period (for now) */
    pwmParams.dutyUnits = PWM_DUTY_COUNTS;      /* Duty is in counts */
    pwmParams.dutyValue = 0;                    /* 0% initial duty cycle */
    PWM_Handle pwm = PWM_open(0, &pwmParams);

    /* This is the timer that generates the DMA signal */
    GPTimerCC26XX_Params params;
    GPTimerCC26XX_Params_init(&params);
    params.width          = GPT_CONFIG_32BIT;
    params.mode           = GPT_MODE_PERIODIC_UP;
    params.debugStallMode = GPTimerCC26XX_DEBUG_STALL_OFF;
    GPTimerCC26XX_Handle hTimer = GPTimerCC26XX_open(1, &params);

    /* Setup DMA transfer table */
    dmaGPT0APriControlTableEntry.ui32Control =  UDMA_MODE_BASIC |                                                  // Basic mode
                                     UDMA_SIZE_16 |                                                                // 16-bit transfers
                                     UDMA_SRC_INC_16 |                                                             // Increment source address as 16-bit
                                     UDMA_DST_INC_NONE |                                                           // Do not increment destination address
                                     UDMA_ARB_1 |                                                                  // Arbitrate system bus for 1 transfer at a time
                                     UDMACC26XX_SET_TRANSFER_SIZE(sizeof(myPwmDutyInCounts) / sizeof(uint16_t));     // Setup number of transfers (in frames of 16-bit)
    dmaGPT0APriControlTableEntry.pvSrcEndAddr = (void *)(myPwmDutyInCounts + (sizeof(myPwmDutyInCounts) / sizeof(uint16_t)) - 1); // Set source end address (mind the pointer arithmetic)
    dmaGPT0APriControlTableEntry.pvDstEndAddr = (void *) (GPT1_BASE + GPT_O_TAMATCHR);  // Write to timer1 (PWM gptimer)

    /* Trigger timer every 50 ms */
    GPTimerCC26XX_Value loadVal = 48000000 / 20 - 1;
    GPTimerCC26XX_setLoadValue(hTimer, loadVal);

    /* Enable GPTimer DMA channel */
    UDMACC26XX_channelEnable(dmaHandle, 1 << UDMA_CHAN_TIMER0_A);

    /* Enable event signal */
    HWREG(GPT0_BASE + GPT_O_DMAEV) = GPT_DMAEV_TATODMAEN;

    PWM_setPeriod(pwm, 100);
    PWM_setDuty(pwm, 10);
    PWM_start(pwm);

    /* Start the update timer */
    GPTimerCC26XX_start(hTimer);

    while (1)
    {
        sleep(time);
    }
}





#include <ti/drivers/PWM.h>
#include <ti/drivers/pwm/PWMTimerCC26XX.h>

/* include driverlib definitions */
#include <ti/devices/cc13x2_cc26x2/driverlib/ioc.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_ints.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_memmap.h>
#define CONFIG_PWM_COUNT 1

/*
 *  ======== pwmCC26XXObjects ========
 */
PWMTimerCC26XX_Object pwmTimerCC26XXObjects[CONFIG_PWM_COUNT];

/*
 *  ======== pwmCC26XXHWAttrs ========
 */

const PWMTimerCC26XX_HwAttrs pwmTimerCC26XXHWAttrs[CONFIG_PWM_COUNT] = {
    /* CONFIG_PWM_0 */
    {
        .pwmPin = CONFIG_GPIO_PWM_0,
        .gpTimerUnit = 0
    },
};

/*
 *  ======== PWM_config ========
 */
const PWM_Config PWM_config[CONFIG_PWM_COUNT] = {
    /* CONFIG_PWM_0 */
    {
        .fxnTablePtr = &PWMTimerCC26XX_fxnTable,
        .object = &pwmTimerCC26XXObjects[0],
        .hwAttrs = &pwmTimerCC26XXHWAttrs[0]
    },
};


const uint_least8_t PWM_count = CONFIG_PWM_COUNT;




#include <ti/drivers/timer/GPTimerCC26XX.h>
#include <ti/drivers/power/PowerCC26XX.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_memmap.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_ints.h>

#define CONFIG_GPTIMER_COUNT 2

/*
 *  ======== gptimerCC26XXObjects ========
 */
GPTimerCC26XX_Object gptimerCC26XXObjects[CONFIG_GPTIMER_COUNT];

/*
 *  ======== gptimerCC26XXHWAttrs ========
 */
const GPTimerCC26XX_HWAttrs gptimerCC26XXHWAttrs[CONFIG_GPTIMER_COUNT] = {
    /* CONFIG_GPTIMER_0, used by CONFIG_PWM_0 */
    {
        .baseAddr = GPT1_BASE,
        .intNum      = INT_GPT1A,
        .intPriority = (~0),
        .powerMngrId = PowerCC26XX_PERIPH_GPT1,
        .pinMux      = GPT_PIN_1A
    },
    /* CONFIG_GPTIMER_1, used by CONFIG_TIMER_0 */
    {
        .baseAddr = GPT0_BASE,
        .intNum      = INT_GPT0A,
        .intPriority = (~0),
        .powerMngrId = PowerCC26XX_PERIPH_GPT0,
        .pinMux      = GPT_PIN_0A
    },
};

/*
 *  ======== GPTimer_config ========
 */
const GPTimerCC26XX_Config GPTimerCC26XX_config[CONFIG_GPTIMER_COUNT] = {
    /* CONFIG_GPTIMER_0 */
    {
        .object    = &gptimerCC26XXObjects[0],
        .hwAttrs   = &gptimerCC26XXHWAttrs[0],
        .timerPart = GPT_A
    },
    /* CONFIG_GPTIMER_1 */
    {
        .object    = &gptimerCC26XXObjects[1],
        .hwAttrs   = &gptimerCC26XXHWAttrs[1],
        .timerPart = GPT_A
    },
};

#include <ti/drivers/dma/UDMACC26XX.h>
#include <ti/devices/cc13x2_cc26x2/driverlib/udma.h>
#include <ti/devices/cc13x2_cc26x2/inc/hw_memmap.h>

UDMACC26XX_Object udmaCC26XXObject;

const UDMACC26XX_HWAttrs udmaCC26XXHWAttrs = {
    .baseAddr        = UDMA0_BASE,
    .powerMngrId     = PowerCC26XX_PERIPH_UDMA,
    .intNum          = INT_DMA_ERR,
    .intPriority     = (~0)
};

const UDMACC26XX_Config UDMACC26XX_config[1] = {
    {
        .object         = &udmaCC26XXObject,
        .hwAttrs        = &udmaCC26XXHWAttrs,
    },
};

实际示例会改变占空比、但您可以对其进行修改、以使其改变频率。

此致、

Arthur