SPI generates only 1 interrupt

richi-d · Joined: 28 Aug 2007 Posts: 106

Hello,

following problem: with activated SPI interrupt there is only 1 intrerrupt after the complete datainput ( byte 1 + byte 2). Datasheet and a college with an other compiler says there has to be 2 interrupt: 1 after first byte(command) and 1 after second byte(data).
Whats my error? herer is the code:
I want to give only the first byte to the RS232 interface

Ttelmah · Guest

Er.
You are setting up the INT_SSP (primary SPI), but reading the byte from the secondary (spi_read2), which your chip doesn't have (the 87J50, has two SPI ports for example.
Use SPI_read, not spi_read2. I'd not be suprised if reading from the wrong port, was stopping the handler from working properly.

Best Wishes

ckielstra · Joined: 18 Mar 2004 Posts: 3680 Location: The Netherlands

richi-d · Joined: 28 Aug 2007 Posts: 106

Oh, this was my last test with:
array[i] = spi_read2 ();

All tests before has been with the right:

array[i] = spi_read ();

The RS232 work fine - no problems. The Data I receive over SPI is also right, but I don´t get 2 interrupts...

Also: | SPI_H_TO_L) this add changes the SPI SLAVE to a master- it seem that there is a error in the CCS. Have a look to the SSP1CON1 register...

ckielstra · Joined: 18 Mar 2004 Posts: 3680 Location: The Netherlands

richi-d · Joined: 28 Aug 2007 Posts: 106

It doesn´t matter if the array[0] is not written- I simple put it out via RS232 in a list. But I changed it.
I see that only 1 interrupt is generated because I can measure it with the oscilloskope at Pin DATA_LED
But i figured out the problem: the interrupt handler is to slow. The first interrupt is generated when the second byte already came in. So the second interrupt can´t occur because the controller is still in the first interrupt routine.
If I delete the lines:
array[i] = spi_read ();
++i;

I can see 2 interrupts but with a very long delay. The result is: I only get the first byte to read, I can´t read the second byte!

I have a very fast SPI device, and it seems that CCS is too slow with his standard modules.
We wrote the test programm with another compiler and it works...

So my question: how can I make the CCS routine faster? The controller is running with 25MHz!

ckielstra · Joined: 18 Mar 2004 Posts: 3680 Location: The Netherlands

You didn't mention your compiler version so I can't verify your remark of the spi_setup() function being wrong.

The CCS compiler makes it very easy to create an interrupt routine but this universal approach comes at the cost of a larger overhead. The compiler saves every possible register you could change in the interrupt and restores the registers on interrupt exit. Depending on the number of registers in your processor the overhead can be in the range 40 to 80 instructions.

My guess is that your interrupt routine including the interrupt overhead takes about 80 instructions. You can measure this yourself in the MPLAB simulator. At 25 MHz this means a maximum of 78,125 bytes per second, or 625,000 bits per second on the SPI bus.

The only way to minimize the CCS interrupt handling overhead is by writing your own interrupt handler. For this the CCS compiler provides two methods:
1) #int_global: This gives you a bare entry point for the interrupt routine. You are in full control but have also the responsibility of saving and restoring all registers you touch. Easy to implement when you have only one short interrupt routine but becomes more complex when you have multiple interrupts.
2) A high priority interrupt, only available on PIC18 processors and higher. Confusingly there are two keywords for the high priority interrupt: HIGH for a high priority where the compiler is saving/restoring the registers, and FAST where this is your responsibility. The FAST keyword is the one you want to use. Requires the definition of HIGH_INTS=TRUE. Not very well supported by the compiler, only one FAST interrupt is allowed in a program. Like in option 1) you are responsible for saving and restoring all registers you touch. Advantages of the FAST interrupt are that you can mix it with other normal interrupts (where the compiler does the register saving/restoring) and it has higher priority so it can interrupt an already active 'normal' interrupt.

I don't have time now, but if you want to I can post example code for the FAST interrupt, this is the most difficult but also fastest interrupt handler. My guess is it will take about 10 instructions to handle your interrupt.