CCS/CC3235MODSF: GPIO28 not responding while using TCK pin as PWM.

SARJU BHATNAGAR

Part Number: CC3235MODSF
Other Parts Discussed in Thread: SYSCONFIG

Tool/software: Code Composer Studio

Hi TI,

whenever we are using TCK pin as PWM, and defining GPIO28 as input pin , this gpio is not taking any input, while changing PWM with another pin, gpio28 is working properly. please let us know why it is happening. please help out us to resolve this issue.

gpio28 in sysconfig pic

pwm sysconfig pic

Br,

Sarju Bhatnagar

over 4 years ago

0 Sarah P over 4 years ago

TI__Mastermind 38980 points

Hi Sarju,

After you build the project in CCS, you should see a folder in the project called Debug/syscfg with the file ti_drivers_config.c. Can you attach that file to this thread?

Best regards,

Sarah

0 SARJU BHATNAGAR over 4 years ago in reply to Sarah P

Expert 1020 points

Thanks for your reply Sarah P,

Please find out ti_drivers_config.c file, attached here.

Fullscreen 3343.ti_drivers_config.c Download

/*
 *  ======== ti_drivers_config.c ========
 *  Configured TI-Drivers module definitions
 *
 *  DO NOT EDIT - This file is generated for the CC3235S_LAUNCHXL
 *  by the SysConfig tool.
 */

#include <stddef.h>
#include <stdint.h>

#ifndef DeviceFamily_CC3220
#define DeviceFamily_CC3220
#endif

#include <ti/devices/DeviceFamily.h>

#include "ti_drivers_config.h"


/*
 *  ============================= Display =============================
 */

#include <ti/display/Display.h>
#include <ti/display/DisplayUart.h>

#define CONFIG_Display_COUNT 1

#define Display_UARTBUFFERSIZE 1024
static char displayUARTBuffer[Display_UARTBUFFERSIZE];

DisplayUart_Object displayUartObject;

const DisplayUart_HWAttrs displayUartHWAttrs = {
    .uartIdx      = CONFIG_UART_0,
    .baudRate     = 115200,
    .mutexTimeout = (unsigned int)(-1),
    .strBuf       = displayUARTBuffer,
    .strBufLen    = Display_UARTBUFFERSIZE
};

const Display_Config Display_config[CONFIG_Display_COUNT] = {
    /* CONFIG_Display_0 */
    {
        .fxnTablePtr = &DisplayUartMin_fxnTable,
        .object      = &displayUartObject,
        .hwAttrs     = &displayUartHWAttrs
    },
};

const uint_least8_t Display_count = CONFIG_Display_COUNT;


/*
 *  =============================== ADC ===============================
 */

#include <ti/drivers/ADC.h>
#include <ti/drivers/adc/ADCCC32XX.h>

#include <ti/devices/cc32xx/driverlib/adc.h>

#define CONFIG_ADC_COUNT 3

/*
 *  ======== adcCCC32XXObjects ========
 */
ADCCC32XX_Object adcCC32XXObjects[CONFIG_ADC_COUNT];

/*
 *  ======== adcCC3220SHWAttrs ========
 */
const ADCCC32XX_HWAttrsV1 adcCC32XXHWAttrs[CONFIG_ADC_COUNT] = {
    /* CP_1_Pilot_ADC */
    {
        .adcPin = ADCCC32XX_PIN_59_CH_2,
    },
    /* voltageSample */
    {
        .adcPin = ADCCC32XX_PIN_60_CH_3,
    },
    /* currentSamples */
    {
        .adcPin = ADCCC32XX_PIN_57_CH_0,
    },
};

/*
 *  ======== ADC_config ========
 */
const ADC_Config ADC_config[CONFIG_ADC_COUNT] = {
    /* CP_1_Pilot_ADC */
    {
        .fxnTablePtr = &ADCCC32XX_fxnTable,
        .object = &adcCC32XXObjects[CP_1_Pilot_ADC],
        .hwAttrs = &adcCC32XXHWAttrs[CP_1_Pilot_ADC]
    },
    /* voltageSample */
    {
        .fxnTablePtr = &ADCCC32XX_fxnTable,
        .object = &adcCC32XXObjects[voltageSample],
        .hwAttrs = &adcCC32XXHWAttrs[voltageSample]
    },
    /* currentSamples */
    {
        .fxnTablePtr = &ADCCC32XX_fxnTable,
        .object = &adcCC32XXObjects[currentSamples],
        .hwAttrs = &adcCC32XXHWAttrs[currentSamples]
    },
};

const uint_least8_t CP_1_Pilot_ADC_CONST = CP_1_Pilot_ADC;
const uint_least8_t voltageSample_CONST = voltageSample;
const uint_least8_t currentSamples_CONST = currentSamples;
const uint_least8_t ADC_count = CONFIG_ADC_COUNT;


/*
 *  =============================== Crypto ===============================
 */

#include <ti/drivers/crypto/CryptoCC32XX.h>

/*
 *  ======== CryptoCC32XXObjects ========
 */
#define CONFIG_Crypto_COUNT 1
CryptoCC32XX_Object cryptoCC32XXObjects[CONFIG_Crypto_COUNT];

/*
 *  ======== Crypto_config ========
 */
const CryptoCC32XX_Config CryptoCC32XX_config[CONFIG_Crypto_COUNT] = {
    /* CONFIG_Crypto_0 */
    {
        .object = &cryptoCC32XXObjects[CONFIG_Crypto_0],
    },
};

const uint_least8_t CONFIG_Crypto_0_CONST = CONFIG_Crypto_0;
const uint_least8_t CryptoCC32XX_count = CONFIG_Crypto_COUNT;


/*
 *  =============================== DMA ===============================
 */

#include <ti/drivers/dma/UDMACC32XX.h>
#include <ti/devices/cc32xx/inc/hw_ints.h>
#include <ti/devices/cc32xx/inc/hw_types.h>
#include <ti/devices/cc32xx/driverlib/rom_map.h>
#include <ti/devices/cc32xx/driverlib/udma.h>

/* Ensure DMA control table is aligned as required by the uDMA Hardware */
static tDMAControlTable dmaControlTable[64] __attribute__ ((aligned (1024)));

/* This is the handler for the uDMA error interrupt. */
static void dmaErrorFxn(uintptr_t arg)
{
    int status = MAP_uDMAErrorStatusGet();
    MAP_uDMAErrorStatusClear();

    /* Suppress unused variable warning */
    (void)status;

    while (1);
}

UDMACC32XX_Object udmaCC3220SObject;

const UDMACC32XX_HWAttrs udmaCC3220SHWAttrs = {
    .controlBaseAddr = (void *)dmaControlTable,
    .dmaErrorFxn     = (UDMACC32XX_ErrorFxn)dmaErrorFxn,
    .intNum          = INT_UDMAERR,
    .intPriority     = (~0)
};

const UDMACC32XX_Config UDMACC32XX_config = {
    .object  = &udmaCC3220SObject,
    .hwAttrs = &udmaCC3220SHWAttrs
};


/*
 *  =============================== GPIO ===============================
 */

#include <ti/drivers/GPIO.h>
#include <ti/drivers/gpio/GPIOCC32XX.h>

#define CONFIG_GPIO_COUNT 5

/*
 *  ======== gpioPinConfigs ========
 *  Array of Pin configurations
 */
GPIO_PinConfig gpioPinConfigs[] = {
    /* Relay_Check_E */
    GPIOCC32XX_GPIO_30 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_LOW,
    /* Relay_Check_L_N */
    GPIOCC32XX_GPIO_28 | GPIO_CFG_IN_NOPULL | GPIO_CFG_IN_INT_RISING,
    /* Red_Led_Indicator */
    GPIOCC32XX_GPIO_25 | GPIO_CFG_IN_PD | GPIO_CFG_IN_INT_NONE,
    /* SS_ISO */
    GPIOCC32XX_GPIO_17 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_MED | GPIO_CFG_OUT_HIGH,
    /* CONFIG_GPIO_HDC2010_INT */
    GPIOCC32XX_GPIO_06 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_FALLING,
};

/*
 *  ======== gpioCallbackFunctions ========
 *  Array of callback function pointers
 *
 *  NOTE: Unused callback entries can be omitted from the callbacks array to
 *  reduce memory usage by enabling callback table optimization
 *  (GPIO.optimizeCallbackTableSize = true)
 */
GPIO_CallbackFxn gpioCallbackFunctions[] = {
    /* Relay_Check_E */
    NULL,
    /* Relay_Check_L_N */
    NULL,
    /* Red_Led_Indicator */
    NULL,
    /* SS_ISO */
    NULL,
    /* CONFIG_GPIO_HDC2010_INT */
    NULL,
};

const uint_least8_t Relay_Check_E_CONST = Relay_Check_E;
const uint_least8_t Relay_Check_L_N_CONST = Relay_Check_L_N;
const uint_least8_t Red_Led_Indicator_CONST = Red_Led_Indicator;
const uint_least8_t SS_ISO_CONST = SS_ISO;
const uint_least8_t CONFIG_GPIO_HDC2010_INT_CONST = CONFIG_GPIO_HDC2010_INT;

/*
 *  ======== GPIOCC32XX_config ========
 */
const GPIOCC32XX_Config GPIOCC32XX_config = {
    .pinConfigs = (GPIO_PinConfig *)gpioPinConfigs,
    .callbacks = (GPIO_CallbackFxn *)gpioCallbackFunctions,
    .numberOfPinConfigs = 5,
    .numberOfCallbacks = 5,
    .intPriority = (~0)
};


/*
 *  =============================== I2C ===============================
 */

#include <ti/drivers/I2C.h>
#include <ti/drivers/i2c/I2CCC32XX.h>
#include <ti/devices/cc32xx/inc/hw_ints.h>
#include <ti/devices/cc32xx/inc/hw_memmap.h>

#define CONFIG_I2C_COUNT 1

/*
 *  ======== i2cCC32XXObjects ========
 */
I2CCC32XX_Object i2cCC32XXObjects[CONFIG_I2C_COUNT];

/*
 *  ======== i2cCC32XXHWAttrs ========
 */
const I2CCC32XX_HWAttrsV1 i2cCC32XXHWAttrs[CONFIG_I2C_COUNT] = {
    /* CONFIG_I2C_HDC */
    {
        .baseAddr = I2CA0_BASE,
        .intNum = INT_I2CA0,
        .intPriority = (~0),
        .clkPin  = I2CCC32XX_PIN_16_I2C_SCL,
        .dataPin = I2CCC32XX_PIN_02_I2C_SDA
    },
};

/*
 *  ======== I2C_config ========
 */
const I2C_Config I2C_config[CONFIG_I2C_COUNT] = {
    /* CONFIG_I2C_HDC */
    {
        .fxnTablePtr = &I2CCC32XX_fxnTable,
        .object = &i2cCC32XXObjects[CONFIG_I2C_HDC],
        .hwAttrs = &i2cCC32XXHWAttrs[CONFIG_I2C_HDC]
    },
};

const uint_least8_t CONFIG_I2C_HDC_CONST = CONFIG_I2C_HDC;
const uint_least8_t I2C_count = CONFIG_I2C_COUNT;


/*
 *  =============================== PWM ===============================
 */

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

#define CONFIG_PWM_COUNT 3

/*
 *  ======== pwmTimerCC32XXObjects ========
 */
PWMTimerCC32XX_Object pwmTimerCC32XXObjects[CONFIG_PWM_COUNT];

/*
 *  ======== pwmTimerCC32XXHWAttrs ========
 */
const PWMTimerCC32XX_HWAttrsV2 pwmTimerCC32XXHWAttrs[CONFIG_PWM_COUNT] = {
    /* Pilot_PWM */
    {
        .pwmPin = PWMTimerCC32XX_PIN_64, /* 64 */
    },
    /* Relay_Enable_2 */
    {
        .pwmPin = PWMTimerCC32XX_PIN_19, /* 19 */
    },
    /* Relay_Enable_1 */
    {
        .pwmPin = PWMTimerCC32XX_PIN_01, /* 01 */
    },
};

/*
 *  ======== PWM_config ========
 */
const PWM_Config PWM_config[CONFIG_PWM_COUNT] = {
    /* Pilot_PWM */
    {
        .fxnTablePtr = &PWMTimerCC32XX_fxnTable,
        .object = &pwmTimerCC32XXObjects[Pilot_PWM],
        .hwAttrs = &pwmTimerCC32XXHWAttrs[Pilot_PWM]
    },
    /* Relay_Enable_2 */
    {
        .fxnTablePtr = &PWMTimerCC32XX_fxnTable,
        .object = &pwmTimerCC32XXObjects[Relay_Enable_2],
        .hwAttrs = &pwmTimerCC32XXHWAttrs[Relay_Enable_2]
    },
    /* Relay_Enable_1 */
    {
        .fxnTablePtr = &PWMTimerCC32XX_fxnTable,
        .object = &pwmTimerCC32XXObjects[Relay_Enable_1],
        .hwAttrs = &pwmTimerCC32XXHWAttrs[Relay_Enable_1]
    },
};

const uint_least8_t Pilot_PWM_CONST = Pilot_PWM;
const uint_least8_t Relay_Enable_2_CONST = Relay_Enable_2;
const uint_least8_t Relay_Enable_1_CONST = Relay_Enable_1;
const uint_least8_t PWM_count = CONFIG_PWM_COUNT;


/*
 *  =============================== Power ===============================
 */
#include <ti/drivers/Power.h>
#include <ti/drivers/power/PowerCC32XX.h>
#include <ti/devices/cc32xx/driverlib/prcm.h>

extern void PowerCC32XX_initPolicy(void);
extern void PowerCC32XX_sleepPolicy(void);
PowerCC32XX_ParkInfo parkInfo[];
/*
 *  This structure defines the configuration for the Power Manager.
 */
const PowerCC32XX_ConfigV1 PowerCC32XX_config = {
    .policyInitFxn             = PowerCC32XX_initPolicy,
    .policyFxn                 = PowerCC32XX_sleepPolicy,
    .enterLPDSHookFxn          = NULL,
    .resumeLPDSHookFxn         = NULL,
    .enablePolicy              = false,
    .enableGPIOWakeupLPDS      = true,
    .enableGPIOWakeupShutdown  = true,
    .enableNetworkWakeupLPDS   = true,
    .wakeupGPIOSourceLPDS      = PRCM_LPDS_GPIO13,
    .wakeupGPIOTypeLPDS        = PRCM_LPDS_FALL_EDGE,
    .wakeupGPIOFxnLPDS         = NULL,
    .wakeupGPIOFxnLPDSArg      = 0,
    .wakeupGPIOSourceShutdown  = PRCM_HIB_GPIO13,
    .wakeupGPIOTypeShutdown    = PRCM_HIB_RISE_EDGE,
    .ramRetentionMaskLPDS      = PRCM_SRAM_COL_1|PRCM_SRAM_COL_2|PRCM_SRAM_COL_3|PRCM_SRAM_COL_4,
    .keepDebugActiveDuringLPDS = false,
    .ioRetentionShutdown       = PRCM_IO_RET_GRP_0|PRCM_IO_RET_GRP_1|PRCM_IO_RET_GRP_2|PRCM_IO_RET_GRP_3,
    .pinParkDefs               = parkInfo,
    .numPins                   = 31
};


/*
 *  =============================== SPI ===============================
 */

#include <ti/drivers/SPI.h>
#include <ti/drivers/spi/SPICC32XXDMA.h>

#include <ti/devices/cc32xx/inc/hw_ints.h>
#include <ti/devices/cc32xx/inc/hw_memmap.h>
#include <ti/devices/cc32xx/inc/hw_types.h>
#include <ti/devices/cc32xx/driverlib/prcm.h>
#include <ti/devices/cc32xx/driverlib/spi.h>
#include <ti/devices/cc32xx/driverlib/udma.h>

#define CONFIG_SPI_COUNT 2

/*
 *  ======== spiCC32XXDMAObjects ========
 */
SPICC32XXDMA_Object spiCC32XXDMAObjects[CONFIG_SPI_COUNT];

uint32_t spiCC32XXSDMAscratchBuf[CONFIG_SPI_COUNT];

/*
 *  ======== spiCC32XXDMAHWAttrs ========
 */
const SPICC32XXDMA_HWAttrsV1 spiCC32XXDMAHWAttrs[CONFIG_SPI_COUNT] = {
    /* CONFIG_NWP_SPI */
    /* Network Processor SPI Bus */
    {
        .baseAddr = LSPI_BASE,
        .intNum = INT_LSPI,
        .intPriority = (~0),
        .spiPRCM = PRCM_LSPI,
        .csControl = SPI_SW_CTRL_CS,
        .csPolarity = SPI_CS_ACTIVEHIGH,
        .pinMode = SPI_4PIN_MODE,
        .turboMode = SPI_TURBO_OFF,
        .scratchBufPtr = &spiCC32XXSDMAscratchBuf[CONFIG_NWP_SPI],
        .defaultTxBufValue = 0,
        .rxChannelIndex = UDMA_CH12_LSPI_RX,
        .txChannelIndex = UDMA_CH13_LSPI_TX,
        .minDmaTransferSize = 100,
        .mosiPin = SPICC32XXDMA_PIN_NO_CONFIG,
        .misoPin = SPICC32XXDMA_PIN_NO_CONFIG,
        .clkPin  = SPICC32XXDMA_PIN_NO_CONFIG,
        .csPin  = SPICC32XXDMA_PIN_NO_CONFIG
    },
    /* GSPI */
    {
        .baseAddr = GSPI_BASE,
        .intNum = INT_GSPI,
        .intPriority = (~0),
        .spiPRCM = PRCM_GSPI,
        .csControl = SPI_SW_CTRL_CS,
        .csPolarity = SPI_CS_ACTIVELOW,
        .pinMode = SPI_3PIN_MODE,
        .turboMode = SPI_TURBO_OFF,
        .scratchBufPtr = &spiCC32XXSDMAscratchBuf[CONFIG_SPI_0],
        .defaultTxBufValue = ~0,
        .rxChannelIndex = UDMA_CH30_GSPI_RX,
        .txChannelIndex = UDMA_CH31_GSPI_TX,
        .minDmaTransferSize = 10,
        .mosiPin = SPICC32XXDMA_PIN_07_MOSI,
        .misoPin = SPICC32XXDMA_PIN_06_MISO,
        .clkPin  = SPICC32XXDMA_PIN_05_CLK,
        .csPin  = SPICC32XXDMA_PIN_NO_CONFIG
    },
};

/*
 *  ======== SPI_config ========
 */
const SPI_Config SPI_config[CONFIG_SPI_COUNT] = {
    /* CONFIG_NWP_SPI */
    {
        .fxnTablePtr = &SPICC32XXDMA_fxnTable,
        .object = &spiCC32XXDMAObjects[CONFIG_NWP_SPI],
        .hwAttrs = &spiCC32XXDMAHWAttrs[CONFIG_NWP_SPI]
    },
    /* CONFIG_SPI_0 */
    {
        .fxnTablePtr = &SPICC32XXDMA_fxnTable,
        .object = &spiCC32XXDMAObjects[CONFIG_SPI_0],
        .hwAttrs = &spiCC32XXDMAHWAttrs[CONFIG_SPI_0]
    },
};

const uint_least8_t CONFIG_SPI_0_CONST = CONFIG_SPI_0;
const uint_least8_t CONFIG_NWP_SPI_CONST = CONFIG_NWP_SPI;
const uint_least8_t SPI_count = CONFIG_SPI_COUNT;


/*
 *  =============================== Timer ===============================
 */

#include <ti/drivers/Timer.h>
#include <ti/devices/cc32xx/inc/hw_memmap.h>
#include <ti/devices/cc32xx/inc/hw_ints.h>
#include <ti/drivers/timer/TimerCC32XX.h>

#define CONFIG_TIMER_COUNT 1

/*
 *  ======== timerCC32XXObjects ========
 */
TimerCC32XX_Object timerCC32XXObjects[CONFIG_TIMER_COUNT];

/*
 *  ======== timerCC32XXHWAttrs ========
 */
const TimerCC32XX_HWAttrs timerCC32XXHWAttrs[CONFIG_TIMER_COUNT] = {
    /* voltageSampllingTimer */
    {
        .baseAddress = TIMERA0_BASE,
        .subTimer    = TimerCC32XX_timer32,
        .intNum      = INT_TIMERA0A,
        .intPriority = (~0)
    },
};

/*
 *  ======== Timer_config ========
 */
const Timer_Config Timer_config[CONFIG_TIMER_COUNT] = {
    /* voltageSampllingTimer */
    {
        .fxnTablePtr = &TimerCC32XX_fxnTable,
        .object      = &timerCC32XXObjects[voltageSampllingTimer],
        .hwAttrs     = &timerCC32XXHWAttrs[voltageSampllingTimer]
    },
};

const uint_least8_t voltageSampllingTimer_CONST = voltageSampllingTimer;
const uint_least8_t Timer_count = CONFIG_TIMER_COUNT;


/*
 *  =============================== UART ===============================
 */

#include <ti/drivers/UART.h>
#include <ti/devices/cc32xx/inc/hw_ints.h>
#include <ti/devices/cc32xx/inc/hw_memmap.h>
#include <ti/drivers/uart/UARTCC32XX.h>

#define CONFIG_UART_COUNT 1

#define UART0_BASE UARTA0_BASE
#define UART1_BASE UARTA1_BASE
#define INT_UART0  INT_UARTA0
#define INT_UART1  INT_UARTA1


static unsigned char uartCC32XXRingBuffer0[32];
UARTCC32XX_Object uartCC32XXObjects0;

static const UARTCC32XX_HWAttrsV1 uartCC32XXHWAttrs0 = {
    .baseAddr           = UART0_BASE,
    .intNum             = INT_UART0,
    .intPriority        = (~0),
    .flowControl        = UARTCC32XX_FLOWCTRL_NONE,
    .ringBufPtr         = uartCC32XXRingBuffer0,
    .ringBufSize        = sizeof(uartCC32XXRingBuffer0),
    .rxPin              = UARTCC32XX_PIN_04_UART0_RX,
    .txPin              = UARTCC32XX_PIN_03_UART0_TX,
    .ctsPin             = UARTCC32XX_PIN_UNASSIGNED,
    .rtsPin             = UARTCC32XX_PIN_UNASSIGNED,
    .errorFxn           = NULL
  };

const UART_Config UART_config[CONFIG_UART_COUNT] = {
    {   /* CONFIG_UART_0 */
        .fxnTablePtr = &UARTCC32XX_fxnTable,
        .object      = &uartCC32XXObjects0,
        .hwAttrs     = &uartCC32XXHWAttrs0
    },
};

const uint_least8_t CONFIG_UART_0_CONST = CONFIG_UART_0;
const uint_least8_t UART_count = CONFIG_UART_COUNT;



/*
 *  =============================== Watchdog ===============================
 */

#include <ti/drivers/Watchdog.h>
#include <ti/drivers/watchdog/WatchdogCC32XX.h>
#include <ti/devices/cc32xx/inc/hw_memmap.h>
#include <ti/devices/cc32xx/inc/hw_ints.h>
#include <ti/devices/cc32xx/inc/hw_types.h>
#include <ti/devices/cc32xx/driverlib/wdt.h>

#define CONFIG_WATCHDOG_COUNT 1

WatchdogCC32XX_Object watchdogCC32XXObjects[CONFIG_WATCHDOG_COUNT];

const WatchdogCC32XX_HWAttrs
    watchdogCC32XXHWAttrs[CONFIG_WATCHDOG_COUNT] = {
    /* CONFIG_WATCHDOG_0: period = 1000 */
    {
        .baseAddr    = WDT_BASE,
        .intNum      = INT_WDT,
        .intPriority = 0x20,
        .reloadValue = 80000000
    },
};

const Watchdog_Config Watchdog_config[CONFIG_WATCHDOG_COUNT] = {
    /* CONFIG_WATCHDOG_0 */
    {
        .fxnTablePtr = &WatchdogCC32XX_fxnTable,
        .object      = &watchdogCC32XXObjects[CONFIG_WATCHDOG_0],
        .hwAttrs     = &watchdogCC32XXHWAttrs[CONFIG_WATCHDOG_0]
    }
};

const uint_least8_t CONFIG_WATCHDOG_0_CONST = CONFIG_WATCHDOG_0;
const uint_least8_t Watchdog_count = CONFIG_WATCHDOG_COUNT;


#include <ti/drivers/power/PowerCC32XX.h>

/*
 * This table defines the parking state to be set for each parkable pin
 * during LPDS. (Device resources must be parked during LPDS to achieve maximum
 * power savings.)  If the pin should be left unparked, specify the state
 * PowerCC32XX_DONT_PARK.  For example, for a UART TX pin, the device
 * will automatically park the pin in a high state during transition to LPDS,
 * so the Power Manager does not need to explictly park the pin.  So the
 * corresponding entries in this table should indicate PowerCC32XX_DONT_PARK.
 */
PowerCC32XX_ParkInfo parkInfo[] = {
/*        PIN                    PARK STATE              Pin Alias
   -----------------  ------------------------------     ---------------*/

  {PowerCC32XX_PIN01, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP10 */
  {PowerCC32XX_PIN02, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP11 */
  {PowerCC32XX_PIN03, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP12 */
  {PowerCC32XX_PIN04, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP13 */
  {PowerCC32XX_PIN05, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP14 */
  {PowerCC32XX_PIN06, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP15 */
  {PowerCC32XX_PIN07, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP16 */
  {PowerCC32XX_PIN08, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP17 */
  {PowerCC32XX_PIN13, PowerCC32XX_WEAK_PULL_DOWN_STD},
  {PowerCC32XX_PIN15, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP22 */
  {PowerCC32XX_PIN16, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* TDI */
  {PowerCC32XX_PIN17, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* TDO */
  {PowerCC32XX_PIN18, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP28 */
  {PowerCC32XX_PIN19, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* TCK */
  {PowerCC32XX_PIN20, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* TMS */
  {PowerCC32XX_PIN21, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* SOP2 */
  {PowerCC32XX_PIN29, PowerCC32XX_WEAK_PULL_DOWN_STD},
  {PowerCC32XX_PIN30, PowerCC32XX_WEAK_PULL_DOWN_STD},
  {PowerCC32XX_PIN45, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP31 */
  {PowerCC32XX_PIN50, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP00 */
  {PowerCC32XX_PIN52, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP32 */
  {PowerCC32XX_PIN53, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP30 */
  {PowerCC32XX_PIN55, PowerCC32XX_WEAK_PULL_UP_STD},   /* GP01 */
  {PowerCC32XX_PIN57, PowerCC32XX_WEAK_PULL_UP_STD},   /* GP02 */
  {PowerCC32XX_PIN58, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP03 */
  {PowerCC32XX_PIN59, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP04 */
  {PowerCC32XX_PIN60, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP05 */
  {PowerCC32XX_PIN61, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP06 */
  {PowerCC32XX_PIN62, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP07 */
  {PowerCC32XX_PIN63, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP08 */
  {PowerCC32XX_PIN64, PowerCC32XX_WEAK_PULL_DOWN_STD},   /* GP09 */
};


#include <ti/drivers/Board.h>

/*
 *  ======== Board_initHook ========
 *  Perform any board-specific initialization needed at startup.  This
 *  function is declared weak to allow applications to override it if needed.
 */
void __attribute__((weak)) Board_initHook(void)
{
}

/*
 *  ======== Board_init ========
 *  Perform any initialization needed before using any board APIs
 */
void Board_init(void)
{
    /* ==== /ti/drivers/Power initialization ==== */
    PRCMCC3200MCUInit();
    Power_init();

    Board_initHook();
}

Please have a look and let me know the issue.

thanks again.

Sarju Bhatnagar

0 Sarah P over 4 years ago in reply to SARJU BHATNAGAR

TI__Mastermind 38980 points

Hi Sarju Bhatnagar,

That looks good. Can you share the snippets in your code to initialize and enable the GPIO interrupt, and to initialize and start the PWM?

Best regards,

Sarah

0 SARJU BHATNAGAR over 4 years ago in reply to Sarah P

Expert 1020 points

Thanks for being connected,

For GPIO :

GPIO_init(); declared inside main. and pin settings in sysconfig are

that's it ,what i am doing for GPIO initialization, After that simply i am trying to read GPIO input using

       if(GPIO_read(Relay_Check_L_N))
        {
            IOT_INFO("Relay L N : HIGH");
        }
        else
        {
            IOT_INFO("Relay L N : LOW");
        }

to check whether GP28 is HIGH or LOW, but it is not changing it's state, it is always low. while giving high 3.3V to it. And this is happening when TCK is used as pwm.

once TCK is replaced with another pwm pin, GPIO28 is responding well.

here is the setting details for PWM:

inside main

    PWM_init();

function to open PWM

static void Relay_Enable_2_Initializer()
{
    /* Period and duty in microseconds */
    uint16_t pwmPeriod = 1000;    //3000; -> 1000 ms for 1KHz frequency

    PWM_Params_init(&params);
    params.dutyUnits = PWM_DUTY_US;
    params.dutyValue = 0;
    params.periodUnits = PWM_PERIOD_US;
    params.periodValue = pwmPeriod;
    params.idleLevel = PWM_IDLE_LOW;
    pwm2 = PWM_open(Relay_Enable_2, &params);
    if (pwm2 == NULL)
    {
        Display_printf(display, 0, 0, " Relay_Enable_2 did not open\n");
        /* CONFIG_PWM_0 did not open */
        ASSERT_ON_ERROR(-1);
        while (1)
            ;
    }
    else
    {
        Display_printf(display, 0, 0, " Relay_Enable_2 opened\n");
    }

//    PWM_Pulse_Generator(250);
}

and to set duty

static void Relay_Enable_1_Pulse_Generator(uint16_t duty) //Duty is an analog value.
{
    PWM_start(pwm1);
    PWM_setDuty(pwm1, duty);
}

that's it.

I hope it could help you to understand the issue.

please let us know, if something is wrong somewhere.

Thanks again,

Sarju Bhatnagar

0 Sarah P over 4 years ago in reply to SARJU BHATNAGAR

TI__Mastermind 38980 points

Hi Sarju Bhatnagar,

The use of the APIs all look correct. The only thing I'll ask you to check is that you are opening the handle pwm2 in Relay_Enable_2_Initializer(), but you are starting pwm1 in Relay_Enable_1_Pulse_Generator(). You may have gotten those switched when you were posting, so please verify in your code.

In your original post, you said "the gpio is not taking any input." Does that mean the GPIO_read is not returning? Is the value not correct? Also, are you testing on a custom board or a LaunchPad?

Best regards,

Sarah

0 SARJU BHATNAGAR over 4 years ago in reply to Sarah P

Expert 1020 points

Hi Sarah P,

Sorry my mistake, Actually that is Relay_Enable_2_Pulse_Generator(), by mistake i took the screenshot of similar function.

actual functions is below -

static void Relay_Enable_2_Pulse_Generator(uint16_t duty) //Duty is an analog value.
{
    PWM_start(pwm2);
    PWM_setDuty(pwm2, duty);
}

secondly, I meant by "the gpio is not taking any input" is gpio is taking input but it is always low, but i am giving high(3.3V) input to it.

and i am using custom board.

please do let me know, if you want to know anything else.

Thanks for your support.

sarju bhatnagar

0 Sarah P over 4 years ago in reply to SARJU BHATNAGAR

TI__Mastermind 38980 points

Hi Sarju,

To verify, you have flashed the application to the device and after starting the PWM, you see additional prints "Relay L N : LOW" to the serial terminal, correct? I'm assuming you are not using the JTAG here.

Can you share your schematic?

Best regards,

Sarah

0 SARJU BHATNAGAR over 4 years ago in reply to Sarah P

Expert 1020 points

HI Sarah,

We are not using JTAG, Using JTAG pins as GPIO and PWM, we are simply using JTAG_TCK pin as PWM to drive DRV 8847 and gpio28 as input to get the feedback from relay weld detection.

Thanks

sarju

0 Sarah P over 4 years ago in reply to SARJU BHATNAGAR

TI__Mastermind 38980 points

Hi Sarju,

I'm trying to determine what is happening in your application. After starting the PWM, do you still see "Relay L N : LOW" printing to the serial terminal?

I tested an example on a LaunchPad that uses TCK as the PWM and reads input from GPIO28 (see attached), and I did not have any issues. There is no internal pin conflict.

/cfs-file/__key/communityserver-discussions-components-files/81/pwmled2_5F00_CC3235SF_5F00_LAUNCHXL_5F00_tirtos_5F00_ccs.zip

Best regards,

Sarah

Code Composer Studio™︎

Code Composer Studio forum

CCS/CC3235MODSF: GPIO28 not responding while using TCK pin as PWM.