AVR Freaks

There is also a setting for timer, which allow timers to pause when you actually pause the program while debugging. 

Not so sure about that?

the UART hardware does all the "timing-sensitive" stuff - all the software sees is the interrupt and status bits.

It certainly should be possible to set a breakpoint in an ISR, and step through it.

Of course, putting a breakpoint in an ISR will mean that you'll miss any further bytes that come in while you're halted or stepping.

(in other words, the bit timing is unaffected; but the byte timing is affected)

And, as  ki0bk and  Heisen have suggested, the project does need to be appropriately configured.    

Similarly for other interrupts; eg, timers ...

Try this setting also,

Okay maybe on PDI interface timers don't run when paused during debugging. Not sure.

Can you be more specific about exactly what it is you are doing, what you expect to happen and what actually happens.

Loads of us have developed comms and timer apps using ICEs and breaking in interrupts and I'm not aware of any general problem in that area. If I write something like:

!main(void) 

#include <avr/interrupt.h>

int main(void)
{
    DDRB = 0xFF;
    UCSR0B = (1 << RXEN0) | (1 << RXCIE0);
    UBRR0 = 103;
    sei();
    while(1) {
    }
}

ISR(USART_RX_vect)
{
    PORTB = UDR0;
}

which is about as minimal as you can get to do RXC (this for mega328P in fact), then if I put a breakpoint on the PORTB= line I would expect it to breakpoint there when bytes started to arrive though this would be predicated on the UART timing being right - if not the RX interrupt may never occur.

Well this is not a solution but it might get you the debugging you need.

What ever you are trying to debug in that ISR, just replace it with a function and try placing breakpoint in that function and see what happens. Does it pause then?

Surely this is not a good idea to call functions from an ISR but try to keep it short do your debugging and later just remove that function and place it's code in the ISR. ( One thing we know for sure is that if your debugged code works in a function surely it will work in that ISR too later, when we remove the function)

OR

If the program does not pause. Try setting a flag in the ISR and let the control get out of the ISR.

volatile uint8_t test_flag = 0;

ISR(USARTC0_RXC_vect)
{
    a=USARTC0_DATA;
   USARTC0_STATUS = 0;      // clearing status reg.

   test_flag = 1;
}

and then later in the main while loop do this :-

int main()
{
    PORTD_DIRSET = 0x10;  // set PORTD pin 4 as a  for LED
    PORTD_OUTSET = 0x10;  // set PORTD pin 4 = 1 (LED ON)
    PORTC.DIRSET = 0x08; //Set Port Pin OUTPUT for UART TX
    PORTC.DIRCLR |= 0x04; //Set Port Pin INPUT for UART RX

    USARTC0_BAUDCTRLA = 105; // Set baud rate 9600
    USARTC0_BAUDCTRLB = 0;
    USARTC0_CTRLC = 0x03; // Set frame format - 8 bit data, 1 stop bit, parity none
    USARTC0_CTRLB |= 0x18; // Enable TX and RX

    USARTC0_CTRLA = (USARTC0_CTRLA & ~USART_RXCINTLVL_gm)|USART_RXCINTLVL_MED_gc;       //Enable interrupt on Rx

    PMIC.CTRL |= PMIC_MEDLVLEX_bm; // Enable PMIC interrupt. 

    sei();     // Enable global interrupts.
    while(1)
    {
        if(test_flag)
        {
            test_flag = 0   // place breakpoint here
 
            // do debugging here
        }
    }
}

Once debugged, place your code back into ISR.