MSP432P401R: Why does the contoller resets during operation?

Hi Amit,

1. I could not reproduce the situation when it stops in the Reset_Handler(). I tried many times, but it did not happen and I have no idea why, so I didn't clear any of the bits in code. At least it is one problem less to think about.

2. I've tried increasing the stack and heap sizes (up to 16k and 8k respectively), but it behaves the same (sometimes it works, sometimes it hangs in Default_Handler(). Memory allocation view looks fine and Stack usage view shows mostly green areas, except for _c_int00 - main - ADC sampling function, where it says in a popup "136 out of 136 bytes used". However, I do not know how to interpret these messages or the values shown.

Do you have any idea on how to investigate this further?

Thank you!

Sure. I have included the project in this message. I suggest running the program at least 10 times successively to catch it in the Default Handler (sometimes it works, sometimes it doesn't).

I hope we can figure this out.

8015.test.zip

Did you place breakpoints in the Default and reset handlers? In my case, after a few tries it hangs in the Default handler. If it has any importance, I'm using SDK 1.50.00.12, because SDK 1.60 has not been released yet.

I guess you commented out the lines that expected responses from the ADC since you do not have it. I've tried this on a MSP432 Launchpad and I confirm that the program does not hang or restart. However, the commented code hanged sometimes when run on my board suggesting a hardware problem with my board. If the problem is hardware-related, how can we find what is causing it?

Hello,

  I am debugging a new bespoke MSP42P401R and reusing code that worked on a previous (older) bespoke 432 board.

  I am just now seeing mysterious vectors to Default_Handler, and googling my problem led me to this post.

  I'll add a breakpoint to the entry statement and let you know what I see....

bob s.

I think I found the cause of the problem, but I cannot explain it.

Firstly, I followed your advice and tested writing to SRAM using this code:

for (i = 0; i < noSamples; i++)
    {
        if (i % 2 == 0)
        {
            ch1d[i] = 0xAAAAAAAA;
            ch2d[i] = 0xAAAAAAAA;
            ch3d[i] = 0xAAAAAAAA;
            ch4d[i] = 0xAAAAAAAA;
        }
        else
        {
            ch1d[i] = 0x55555555;
            ch2d[i] = 0x55555555;
            ch3d[i] = 0x55555555;
            ch4d[i] = 0x55555555;
        }
    }

It worked successfully. However, when using my code, it sometimes hanged in the Default_Handler():

for (i = 0; i < noSamples; i++)
    {
        if (i % 2 == 0)
        {
            ch1d[i] = ADS131A04_LSB*Int24BitTwoComplementToSignedInt(0xAAAAAAAA);
            ch2d[i] = ADS131A04_LSB*Int24BitTwoComplementToSignedInt(0xAAAAAAAA);
            ch3d[i] = ADS131A04_LSB*Int24BitTwoComplementToSignedInt(0xAAAAAAAA);
            ch4d[i] = ADS131A04_LSB*Int24BitTwoComplementToSignedInt(0xAAAAAAAA);
        }
        else
        {
            ch1d[i] = ADS131A04_LSB*Int24BitTwoComplementToSignedInt(0x55555555);
            ch2d[i] = ADS131A04_LSB*Int24BitTwoComplementToSignedInt(0x55555555);
            ch3d[i] = ADS131A04_LSB*Int24BitTwoComplementToSignedInt(0x55555555);
            ch4d[i] = ADS131A04_LSB*Int24BitTwoComplementToSignedInt(0x55555555);
        }
    }

// 24 bit 2's complement to signed int
int Int24BitTwoComplementToSignedInt(unsigned int val)
{
    return (0x800000 & val ? (int)(0x7FFFFF & val) - 0x800000 : val);
}

#define ADS131A04_LSB                           0.000000298023223876953125 // [V]

What is wrong in the code that causes this behavior? Can you give me an advice? You can check the test project I uploaded a few messages ago.

ch1d is float. noSamples is 1000. Trying with 0x00AA.AAAA and 0x0055.5555 gives the same issue. I've tried:

ch1d[i] = (float)ADS131A04_LSB*(float)Int24BitTwoComplementToSignedInt(readDataCh1[i]);

but the same.

I've tested the line in the while loop. This is the entire main():

#define noSamples   1000
float ch1d[noSamples];

int main(void)
{
    // Enabling the FPU with stacking enabled for floating point calculations
    MAP_FPU_enableModule();
    MAP_FPU_enableLazyStacking();

    Clock_System_init();

    //MAP_Interrupt_enableMaster(); // Enabling MASTER interrupts; with or without it, it hangs
    while(1)
    {
        ch1d[0] = (float)ADS131A04_LSB*(float)Int24BitTwoComplementToSignedInt(0x00AAAAAA);
        //Timer32_sleep_cycles(480000); // 1000 us @ MCLK = 48 MHz
    }
}

I confirm that it hangs in Default_Handler(). However, I found something very interesting: if I use my Timer32 sleep function in the while loop with 1ms sleep period every iteration it works, but if I use e.g. a 100us sleep period every iteration, it hangs in Default_Handler().

Could the problem be that it is writing too fast to SRAM (ch1d)?

Hi,

This is Clock_System_init():

void Clock_System_init(void)
{
	// Stop Watchdog
	MAP_WDT_A_holdTimer();
	MAP_Interrupt_disableMaster();

	// Setting the external clock frequency
	MAP_CS_setExternalClockSourceFrequency(32768, 48000000);
	MAP_PCM_setCoreVoltageLevel(PCM_VCORE1);

	// Configuring pins for crystal usage
	MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_PJ, GPIO_PIN0 | GPIO_PIN1, GPIO_PRIMARY_MODULE_FUNCTION); // LFXT
	MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_PJ, GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION); // HFXT

	//MAP_FlashCtl_setWaitState(FLASH_BANK0, 1);
	//MAP_FlashCtl_setWaitState(FLASH_BANK1, 1);

	MAP_FlashCtl_setWaitState(FLASH_BANK0, 2); // For 48 MHz
	MAP_FlashCtl_setWaitState(FLASH_BANK1, 2); // For 48 MHz

	// Starting LFXT in non-bypass mode without a timeout
	MAP_CS_startLFXT(false);
	// Starting HFXT in non-bypass mode without a timeout
	MAP_CS_startHFXT(false);

	// Initializing MCLK, HSMCLK, SMCLK and ACLK
	MAP_CS_initClockSignal(CS_MCLK, CS_HFXTCLK_SELECT, CS_CLOCK_DIVIDER_1);
	MAP_CS_initClockSignal(CS_HSMCLK, CS_HFXTCLK_SELECT, CS_CLOCK_DIVIDER_1); // Shares clock source with SMCLK
	MAP_CS_initClockSignal(CS_SMCLK, CS_HFXTCLK_SELECT, CS_CLOCK_DIVIDER_2); // Maximum HSMCLK / 2; shares clock source with HSMCLK
	MAP_CS_initClockSignal(CS_ACLK, CS_LFXTCLK_SELECT, CS_CLOCK_DIVIDER_1); // Maximum 128 kHz
	MAP_CS_initClockSignal(CS_BCLK, CS_LFXTCLK_SELECT, CS_CLOCK_DIVIDER_1); // Maximum 32768 kHz
}

I've tested the code on a MSP432 Launchpad and I confirm that it works fine. So the problem is with my board.

I followed the advice to test every interrupt to see what is causing the problem. So I wrote handlers for all interrupts (with a while loop inside) and tested them one by one. I found that it hangs in:

HardFault_Handler() (always)

MemManage_Handler() (sometimes)

WDT_A_IRQHandler() (sometimes) - Although WDT is put on hold at the start of the program

EUSCIA3_IRQHandler() (sometimes) - Although nothing is connected to EUSCIA3

EUSCIB3_IRQHandler() (sometimes) - Although nothing is connected to EUSCIB3

T32_INT2_IRQHandler() (sometimes) - Why INT2?

PORT3_IRQHandler() (sometimes) - ?

I had to run the program many times to catch it hanging in one of the interrupts I marked "sometimes". It is possible that it could hang in other interrupts which I missed, because I haven't run the program enough times.

Do you have any ideas how to further investigate the issue?

I got stuck, because the schematic looks fine and I do not know what to understand from these interrupts in order to find the cause of the problem.

It is curious that there wasn't any problem until a few weeks ago, and I haven't made any changes to the board.

I got stuck, because the schematic looks fine and I do not understand the cause of the interrupts.

It is curious that the program worked until a few weeks ago and I haven't made changes to the board.