Other Parts Discussed in Thread: MMWAVEICBOOST,
Hi there,
I am working with the mmWave develop kit [http://www.ti.com/tool/MMWAVEICBOOST].
and I am having problems using interrupts with the master sub-system (mss) of IWR6843 [https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&uact=8&ved=2ahUKEwj__aGJw5TkAhX9GrkGHRZKBfgQFjACegQIBRAC&url=http%3A%2F%2Fwww.ti.com%2Flit%2Fgpn%2Fiwr6843&usg=AOvVaw0vYExXj5QI9GU2ulOixEyw].
The problem is that, I managed to configure the GPIOs 0, 1 and 2, and it works perfectly, just like the example of mmWave_SDK GPIO driver, and else, I managed to configure the GPIO 3 just like the other and it works too. But, when I tried to config and use the GPIO of other ports (like GPIO 30 or 31 of port D), the program compiles, but the interrupt is not detected.
I am using a Pull-Down 10k Ohm resistor on the interrpt GPIO. The code that I am using is the lab19 of the industrial toolbox (50m Outdoor People Tracking and False Detection Filtering). The code of MmwDemo_mssInitTask is shown below.
My question is about why the interrupts on GPIOs of ports B, C and D do not work properly and port A works perfectly? What do I have to do to set ports B, C and D interrupts?
Code:
volatile bool flag_teste = true;
static void myGPIOCallbackFxn(unsigned int index)
{
flag_teste = false;
}
void MmwDemo_mssInitTask(UArg arg0, UArg arg1)
{
int32_t errCode;
MMWave_InitCfg initCfg;
UART_Params uartParams;
Task_Params taskParams;
Semaphore_Params semParams;
Mailbox_Config mboxCfg;
DMA_Params dmaParams;
DMA_Handle dmaHandle;
Error_Block eb;
/* Debug Message: */
System_printf("Debug: MMWDemoMSS Launched the Initialization Task\n");
MmwDemo_printHeapStats();
/*****************************************************************************
* Initialize the mmWave SDK components:
*****************************************************************************/
/* Pinmux setting */
/* Setup the PINMUX to bring out the UART-1 */
#ifdef SOC_XWR68XX // copied from driver test code
Pinmux_Set_FuncSel(SOC_XWR68XX_PINN5_PADBE, SOC_XWR68XX_PINN5_PADBE_MSS_UARTA_TX);
Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINN5_PADBE, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
Pinmux_Set_FuncSel(SOC_XWR68XX_PINN4_PADBD, SOC_XWR68XX_PINN4_PADBD_MSS_UARTA_RX);
Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINN4_PADBD, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
/* Setup the PINMUX to bring out the MSS UART-3 */
Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINF14_PADAJ, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
Pinmux_Set_FuncSel(SOC_XWR68XX_PINF14_PADAJ, SOC_XWR68XX_PINF14_PADAJ_MSS_UARTB_TX);
/* Setup the PINMUX to bring out the DSS UART */
Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINP8_PADBM, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
Pinmux_Set_FuncSel(SOC_XWR68XX_PINP8_PADBM, SOC_XWR68XX_PINP8_PADBM_DSS_UART_TX);
/* Interrupt Dev - GPIO pin config */
Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINH13_PADAB, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
Pinmux_Set_FuncSel(SOC_XWR68XX_PINH13_PADAB, SOC_XWR68XX_PINH13_PADAB_GPIO_0); //PIN H13 - GPIO 0
Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINJ13_PADAC, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
Pinmux_Set_FuncSel(SOC_XWR68XX_PINJ13_PADAC, SOC_XWR68XX_PINJ13_PADAC_GPIO_1); //PIN J13 - GPIO 1
Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINK13_PADAZ, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
Pinmux_Set_FuncSel(SOC_XWR68XX_PINK13_PADAZ, SOC_XWR68XX_PINK13_PADAZ_GPIO_2); //PIN K13 - GPIO 2
Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINE15_PADAG, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
Pinmux_Set_FuncSel(SOC_XWR68XX_PINE15_PADAG, SOC_XWR68XX_PINE15_PADAG_GPIO_30); //PIN R4 - GPIO 30
Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINE13_PADAF, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
Pinmux_Set_FuncSel(SOC_XWR68XX_PINE13_PADAF, SOC_XWR68XX_PINE13_PADAF_GPIO_3); //PIN R4 - GPIO 3
/* Initialize the UART */
UART_init();
/* Initialize the DMA */
DMA_init ();
/* Open the DMA Instance */
DMA_Params_init(&dmaParams);
dmaHandle = DMA_open(0, &dmaParams, &errCode);
if (dmaHandle == NULL)
{
printf ("Error: Unable to open the DMA Instance [Error code %d]\n", errCode);
return;
}
/* Initialize the Mailbox */
Mailbox_init(MAILBOX_TYPE_MSS);
/*****************************************************************************
* Open & configure the drivers:
*****************************************************************************/
/* Setup the default UART Parameters */
UART_Params_init(&uartParams);
uartParams.clockFrequency = gMmwMssMCB.cfg.sysClockFrequency;
uartParams.baudRate = gMmwMssMCB.cfg.commandBaudRate;
uartParams.isPinMuxDone = 1U;
/* Open the UART Instance */
gMmwMssMCB.commandUartHandle = UART_open(0, &uartParams);
if (gMmwMssMCB.commandUartHandle == NULL)
{
System_printf("Error: MMWDemoMSS Unable to open the Command UART Instance\n");
return;
}
/* Setup the default UART Parameters */
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.clockFrequency = gMmwMssMCB.cfg.sysClockFrequency;
uartParams.baudRate = gMmwMssMCB.cfg.loggingBaudRate;
uartParams.isPinMuxDone = 1U;
uartParams.dmaHandle = dmaHandle;
uartParams.txDMAChannel = 1U;
uartParams.rxDMAChannel = 2U;
/* Open the Logging UART Instance: */
gMmwMssMCB.loggingUartHandle = UART_open(1, &uartParams);
if (gMmwMssMCB.loggingUartHandle == NULL)
{
System_printf("Error: MMWDemoMSS Unable to open the Logging UART Instance\n");
return;
}
/*****************************************************************************
* Creating communication channel between MSS & DSS
*****************************************************************************/
/* Create a binary semaphore which is used to handle mailbox interrupt. */
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_BINARY;
gMmwMssMCB.mboxSemHandle = Semaphore_create(0, &semParams, NULL);
/* Setup the default mailbox configuration */
Mailbox_Config_init(&mboxCfg);
/* Setup the configuration: */
mboxCfg.chType = MAILBOX_CHTYPE_MULTI;
mboxCfg.chId = MAILBOX_CH_ID_0;
mboxCfg.writeMode = MAILBOX_MODE_BLOCKING;
mboxCfg.readMode = MAILBOX_MODE_CALLBACK;
mboxCfg.readCallback = &MmwDemo_mboxCallback;
/* Initialization of Mailbox Virtual Channel */
gMmwMssMCB.peerMailbox = Mailbox_open(MAILBOX_TYPE_DSS, &mboxCfg, &errCode);
if (gMmwMssMCB.peerMailbox == NULL)
{
/* Error: Unable to open the mailbox */
System_printf("Error: Unable to open the Mailbox to the DSS [Error code %d]\n", errCode);
return;
}
/* Create task to handle mailbox messages */
Task_Params_init(&taskParams);
taskParams.stackSize = 4*1024;
taskParams.priority = 4;
Task_create(MmwDemo_mboxReadTask, &taskParams, NULL);
/*****************************************************************************
* Create Event to handle mmwave callback and system datapath events
*****************************************************************************/
/* Default instance configuration params */
Error_init(&eb);
gMmwMssMCB.eventHandle = Event_create(NULL, &eb);
if (gMmwMssMCB.eventHandle == NULL)
{
DebugP_assert(0);
return ;
}
/*****************************************************************************
* mmWave: Initialization of the high level module
*****************************************************************************/
/* Initialize the mmWave control init configuration */
memset ((void*)&initCfg, 0 , sizeof(MMWave_InitCfg));
/* Populate the init configuration for mmwave library: */
initCfg.domain = MMWave_Domain_MSS;
initCfg.socHandle = gMmwMssMCB.socHandle;
initCfg.eventFxn = MmwDemo_mssMmwaveEventCallbackFxn;
initCfg.linkCRCCfg.useCRCDriver = 1U;
initCfg.linkCRCCfg.crcChannel = CRC_Channel_CH1;
initCfg.cfgMode = MMWave_ConfigurationMode_FULL;
initCfg.executionMode = MMWave_ExecutionMode_COOPERATIVE;
initCfg.cooperativeModeCfg.cfgFxn = MmwDemo_mssMmwaveConfigCallbackFxn;
initCfg.cooperativeModeCfg.openFxn = MmwDemo_mssMmwaveOpenCallbackFxn;
initCfg.cooperativeModeCfg.closeFxn = MmwDemo_mssMmwaveCloseCallbackFxn;
initCfg.cooperativeModeCfg.startFxn = MmwDemo_mssMmwaveStartCallbackFxn;
initCfg.cooperativeModeCfg.stopFxn = MmwDemo_mssMmwaveStopCallbackFxn;
/* Initialize and setup the mmWave Control module */
gMmwMssMCB.ctrlHandle = MMWave_init (&initCfg, &errCode);
if (gMmwMssMCB.ctrlHandle == NULL)
{
/* Error: Unable to initialize the mmWave control module */
System_printf("Error: MMWDemoMSS mmWave Control Initialization failed [Error code %d]\n", errCode);
return;
}
System_printf("Debug: MMWDemoMSS mmWave Control Initialization was successful\n");
/* Synchronization: This will synchronize the execution of the control module
* between the domains. This is a prerequiste and always needs to be invoked. */
while (1)
{
int32_t syncStatus;
/* Get the synchronization status: */
syncStatus = MMWave_sync (gMmwMssMCB.ctrlHandle , &errCode);
if (syncStatus < 0)
{
/* Error: Unable to synchronize the mmWave control module */
System_printf ("Error: MMWDemoMSS mmWave Control Synchronization failed [Error code %d]\n", errCode);
return;
}
if (syncStatus == 1)
{
/* Synchronization acheived: */
break;
}
/* Sleep and poll again: */
Task_sleep(1);
}
/*****************************************************************************
* Launch the mmWave control execution task
* - This should have a higher priority than any other task which uses the
* mmWave control API
*****************************************************************************/
Task_Params_init(&taskParams);
taskParams.priority = 6;
taskParams.stackSize = 4*1024;
Task_create(MmwDemo_mmWaveCtrlTask, &taskParams, NULL);
/*****************************************************************************
* Create a data path management task to handle data Path events
*****************************************************************************/
Task_Params_init(&taskParams);
taskParams.priority = 4;
taskParams.stackSize = 4*1024;
Task_create(MmwDemo_mssCtrlPathTask, &taskParams, NULL);
/*****************************************************************************
* Create an application task to handle high layer processing
*****************************************************************************/
/* Create a binary semaphore for application task to pend */
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_BINARY;
gMmwMssMCB.appSemHandle = Semaphore_create(0, &semParams, NULL);
Task_Params_init(&taskParams);
taskParams.priority = 2;
taskParams.stackSize = 4*1024;
Task_create(MmwDemo_appTask, &taskParams, NULL);
/*****************************************************************************
* At this point, MSS and DSS are both up and synced. Configuration is ready to be sent.
* Start CLI to get configuration from user
*****************************************************************************/
MmwDemo_CLIInit();
/*****************************************************************************
* Benchmarking Count init
*****************************************************************************/
/* Configure benchmark counter */
Pmu_configureCounter(0, 0x11, FALSE);
Pmu_startCounter(0);
GPIO_init();
GPIO_setConfig(SOC_XWR68XX_GPIO_30, GPIO_CFG_INPUT | GPIO_CFG_IN_INT_RISING | GPIO_CFG_IN_INT_LOW);
GPIO_setCallback(SOC_XWR68XX_GPIO_30, myGPIOCallbackFxn);
GPIO_enableInt (SOC_XWR68XX_GPIO_30);
System_printf ("Debug: Waiting GPIO to be activated\n");
while(flag_teste);
System_printf ("Debug: GPIO activated\n");
return;
}
