ILLOPA exception on C167CR-LM

That ISR is very seriously broken. It is many, many, many times too large and tries to do things a 0.5ms ISR should not try to do.

Do split your code into ISR to collect events and a main loop that process the events. Your ISR shouldn't be larger than what you can view at the same time without selecting a microscopic font.

How have you made sure that for any sequence of input stimuli, your ISR manages to do all work in 0.5ms? If y ou can't guarantee that - why even bother to have the code in the ISR if it isn't critical enough that it _must_ be done within 0.5ms?

That ISR is very seriously broken. It is many, many, many times too large and tries to do things a 0.5ms ISR should not try to do.

Do split your code into ISR to collect events and a main loop that process the events. Your ISR shouldn't be larger than what you can view at the same time without selecting a microscopic font.

How have you made sure that for any sequence of input stimuli, your ISR manages to do all work in 0.5ms? If y ou can't guarantee that - why even bother to have the code in the ISR if it isn't critical enough that it _must_ be done within 0.5ms?

This ISR rotine is a quarter of another one in another application for the same boards in the same plant, and it runs always good ...

There are stunt drivers that can drive their cars on two wheels - that doesn't mean that it is good to drive a car with two wheels in the air...

your ISR is miles long. it contains wasteful references to array elements, multiple loops...
try what Per suggested: move the whole block outside of interrupt context - put it in a function and call it from your main loop. what happens then?
again: the fact that code works means nothing beyond that it does not fail on that hardware, under certain circumstance

I cannot modify the structure of this program.
It's not my property.
I had received this code with this function by the company customer and I removed some unuseful pieces and add a new part.
I cannot split this routine.

Hi Marco,

Back to your original question: what causes the Illegal Operation trap?
You should add a trap handler to collect some debugging information (address of the offending opcode, contents of some CPU registers etc.) Soon you'll be able to map the offending opcode to the exact line of source code.

Regards,
- mike

Small correction.
Just looked it up: ILLOPA is 'Illegal Word Operand Access.' It happens when a word access is attempted at an odd address. Look out for unaligned pointers. The method I suggested should allow you to pinpoint the exact line of source code and the offending unaligned pointer.

Thanks Mike,

so at this moment I've a trap function that, in case of ILLOPA event, print a string "ILLOPA trap!" on serial link.
I can add here a complete printf whith more informations.
Now I try to understand what are the registers or pointers of interest about my problem.

Thank you very much.

Marco

See the MCU manual. The C167 CPU will push PSW, CSP and IP onto the system stack. Print them. CSP and IP will point to the offending instruction. Using a disassembler, you'll be able to map the instruction to the source code.

More thanks.

Marco

Hello Mike,

I looked to User Manual but is written that IP and CSP are not directly accessible, so how can I print IP and CSP?

Thanks

I looked to User Manual but is written that IP and CSP are not directly accessible

You mean this, right?
The IP register is not mapped into the C167CS's address space, and thus it is not directly accessible by the programmer

That's true, but why would you want to read IP in the trap handler? It will not do you any good.
You don't need to read the actual registers. You need the contents of those registers at the time when the trap occured. And those are saved on the stack by the CPU (see manual, section on trap functions.) If I remember correctly, Keil's C166 compiler has an intrinsic function for popping words off the stack. _pop_(), maybe? Look it up. Here is what I would do:

void trap_handler(void)
{
  uint16_t psw, csp, ip;
  ip = _pop_();
  csp = _pop_();
  psw = _pop_();
  ... print psw, csp, ip ...
}

You are correct.

Summary: #include <intrins.h>
int _pop_ (void);
Description:
The _pop_ function inserts a POP instruction into the program which pops the next word from the system stack.
Return Value:
The _pop_ function returns the 16-bit value poped from the system stack.

Example:

#include <intrins.h>
void testpop (void) {
   volatile unsigned temp;
   _push_ (temp);
   temp = _pop_ ();
}

you may want to have a look at the Keil provided traps.c file, too.

Yes, Ok.

I've in my project a custom version of traps.c.

Using the calls to _pop_ function I will insert them in a function called by ILLOPA trap in my traps.c.

Thanks.

Using the calls to _pop_ function I will insert them in a function called by ILLOPA trap in my traps.c

Be careful, though. Each function call pushes more data onto the stack. You have to account for that when trying to extract the saved PSW, CSP, IP. The three simple pops will not do.