TMS320F28379D: Enable CAN peripherals while debugger is paused?

Diane Haldeman

Part Number: TMS320F28379D
Other Parts Discussed in Thread: CODECOMPOSER

Tool/software:

Is there a way to enable the CAN peripherals while a debug session is paused?

I'm writing unit tests via DSS, I'd like my test script to pause the application, write a CAN msg, then manually invoke the application's CAN RX interrupt:

        # get the current location where DSSUtils paused (at end of initialization() called from stdby_Init())
        curLocation = self.__class__.dss_utils.debug_session.memory.readRegister("PC")
        
        # send a valid NOP cmd
        msgt = ntcanfd.CanMsgT()
        msgt.id11 = 0x018
        msgt.set_data8_len(8)
        msgt.set_data8_byte(0x11, 0x0, 0x0, 0x13, 0x88, 0xFF, 0xFF, 0x0)
                            
        # send CAN message in background
        result = self.can_net1.can_send(msgt)
        
        # invoke the CAN RX interrupt to make the application receive the CAN msg
        self.__class__.dss_utils.debug_session.memory.writeRegister("PC", CAN_rx_isr_start_address)
        bp = self.__class__.dss_utils.debug_session.breakpoint.add(CAN_rx_isr_end_address)
        self.__class__.dss_utils.debug_session.target.run()
        self.__class__.dss_utils.debug_session.breakpoint.remove(bp)
        
        # go back to the previous location (end of initialization())
        self.__class__.dss_utils.debug_session.memory.writeRegister("PC", curLocation)
        
        # continue to the end of stdby_Init
        bp = self.__class__.dss_utils.debug_session.breakpoint.add(stdby_Init_end_address)
        self.__class__.dss_utils.debug_session.target.run()
        self.__class__.dss_utils.debug_session.breakpoint.remove(bp)

However, whenever the debug session is paused, the CAN message is not being transmitted (I'm monitoring all CAN traffic with an external tool, ESD's CANreal).

If instead of pausing the application, I let it run in the background (via debug_session.target.runAsynch()), the CAN msg is transmitted successfully.

Thank you

over 1 year ago

0 Ricky Lau over 1 year ago

TI__Genius 13105 points

Hi Diane,

I've contacted an expert in this area to look into this further.

The current thinking is that we suspect the problem is that while the target is halted, the peripherals are not being clocked, and therefore the transmissions will not work. But I'm hoping to get additional insight on this area to confirm this.

Thanks,

Ricky

0 OliverP over 1 year ago

TI__Intellectual 1310 points

Hi Diane,

Please try enabling real-time mode (AllowInterruptsWhenHalted) as described here: https://software-dl.ti.com/ccs/esd/documents/users_guide/sdto_dss_handbook.html?highlight=scripting#debugger-properties

Oliver

0 Diane Haldeman over 1 year ago in reply to OliverP

Prodigy 160 points

Oliver,

That didn't work for me.

After enabling real-time mode:

self.debug_session.options.setBoolean("AllowInterruptsWhenHalted", True)

If I look at the actual value, it's still False:

I also tried following the instructions here: https://e2e.ti.com/support/tools/code-composer-studio-group/ccs/f/code-composer-studio-forum/663179/ccs-ccstudio-keystone-setting-allowinterruptswhenhalted-doesn-t-work-anymore-in-ccs-scripting-console?tisearch=e2e-sitesearch&keymatch=AllowInterruptsWhenHalted# to edit the PropertiesDB.xml file, but that didn't work either.

I see this in the DSS trace:

Do you have another suggestion?

Thank you,

Diane

0 Diane Haldeman over 1 year ago in reply to Diane Haldeman

Prodigy 160 points

I referenced this posting: https://e2e.ti.com/support/tools/code-composer-studio-group/ccs/f/code-composer-studio-forum/691571/ccs-tms320f2812-debug-scripting-server-dss-interferes-with-program/2550200?tisearch=e2e-sitesearch&keymatch=AllowInterruptsWhenHalted#2550200 which directed me to clear the ST1 DBGM bit before setting "AllowInterruptsWhenHalted". This now correctly sets AllowInterruptsWhenHalted, but still the CAN message isn't being transmitted:

        self.debug_session.memory.loadProgram(self.get_out_filename())
        
        cur_ST1_value = self.debug_session.memory.readRegister("ST1")
        cur_ST1_value &= ~0b0000000000000010  # clear the DBGM bit
        self.debug_session.memory.writeRegister("ST1", cur_ST1_value)

        # Enable real-time mode
        self.debug_session.options.setBoolean("AllowInterruptsWhenHalted", True)

When I check on the "AllowInterruptsWhenHalted" (via debug_session.options.getBoolean("AllowInterruptsWhenHalted") I see this in the DSS trace:

0 Ricky Lau over 1 year ago in reply to Diane Haldeman

TI__Genius 13105 points

Diane,

Do you have more info on how self.can_net1.can_send(msgt) is implemented. Since it is not part of DSS, it might be useful for us to know what it is actually doing.

Thanks,

Ricky

0 Diane Haldeman over 1 year ago in reply to Ricky Lau

Prodigy 160 points

Ricky,

The can_send() msg was implemented by a 3rd party library (ESD's python/SWIG implementation of CAN). I've attached this python implementation, but I'm not sure how much it will help, since it's a SWIG implementation, you won't be able to see the underlying C classes. (I had to rename the file to end with ".txt" to get the upload to work):

ntcanfd.py.txt

Note, if I try to generate CAN traffic using a different mechanism (Ex: ESD's CANreal application), no CAN msgs are transmitted while the debug session is paused.

I also tried adding the following to my C application's initialization code, but it didn't help:

    // Configure the CAN interrupts as real-time so that they'll continue to fire when the debugger is paused
    SetDBGIER(0x0100);

In an attempt to simplify the scenario by removing DSS, I tried running the CodeComposer debugger in "realtime mode":

I get this error:

When I select "Rude Retry" the debug session starts. I can transmit CAN traffic while the debugger is running, but when I pause the debugger, no CAN msgs will go out.

Thank you,

Diane

0 Ricky Lau over 1 year ago in reply to Diane Haldeman

TI__Genius 13105 points

Diana,

Thanks for providing the additional information. We will review and let you know if we find anything else out and other suggestions to try.

Regards,

Ricky

0 Diane Haldeman over 1 year ago in reply to Ricky Lau

Prodigy 160 points

Ricky,

Just checking, any other suggestions?

Thank you,

Diane

0 Ki over 1 year ago in reply to Diane Haldeman

TI__Guru**** 472451 points

Hi Diane,

Sorry for the delay. We are still investigating.

0 Ki over 1 year ago in reply to Ki

TI__Guru**** 472451 points

Diane Haldeman said:
Note, if I try to generate CAN traffic using a different mechanism (Ex: ESD's CANreal application), no CAN msgs are transmitted while the debug session is paused.

Please note that for servicing interrupts with the CPU is halted, more needs to be done than just enabling realtime mode.

Please see: https://software-dl.ti.com/ccs/esd/training/modules/realtime_debug/sdoapps_mod_f28x_ccsv6_real-time-debug.pptx

Also see this video: https://www.ti.com/video/3869986306001

Thanks

0 Diane Haldeman over 1 year ago in reply to Ki

Prodigy 160 points

ki,

I referenced the Powerpoint and video, but I'm still struggling.

Leaving DSS out of the scenario for now, I was able to get CPU timer0 interrupts to fire when a CCS debugger is paused. However I still can't get a CAN interrupt to fire.

In my initialization code I added:

    // Configure the CAN and CPUtimer0 interrupts as real-time so that they'll continue to fire when the debugger is paused
    SetDBGIER(INTERRUPT_CPU_INT9 | INTERRUPT_CPU_INT1);

And for the CPU timer0, I added the following, but I couldn't find a comparable setting for a CAN emulation mode:

    // set CPU timer 0 so that it continues to run when the debugger is paused
    CPUTimer_setEmulationMode(CPUTIMER0_BASE, CPUTIMER_EMULATIONMODE_RUNFREE);

Then I start a normal debug session, and pause after I get past my initialization code. Then I select the "Enable Silicon Real-time mode" button.

Then in my watchlist/Expressions I enabled "Continuous Refresh" and I can see a counter that the CPU timer0 is updating:

But when I generate CAN traffic (via the 3rd-party ESD Canreal tool), the message doesn't go out.

If I continue the debugger, then I can send CAN traffic and the CAN ISR fires:

Does CAN have an emulation mode setting? I see comparable settings for EPWM, DMA, CMPSS, uPP.

Thank you,

Diane

0 Ki over 1 year ago in reply to Diane Haldeman

TI__Guru**** 472451 points

It looks like the base real-time support for interrupts is working but I can't explain why the CAN specific interrupts is not.

I will bring this thread to the attention of the device experts for further investigation.

+1 QJ Wang over 1 year ago in reply to Ki

TI__Guru**** 198766 points

Hi Diane,

The DCAN module doesn't support emulation mode.

C2000™︎ microcontrollers

C2000 microcontrollers forum

TMS320F28379D: Enable CAN peripherals while debugger is paused?