Using multiple external interrupts in PIC

Question

I've used PIC16F877 (datasheet) for several projects. For a single external pin change interrupts, you can use PORTB0 interrupt. But now I need to support 8 independent external pin change interrupts, in a single circuit.

In the datasheet it says there are 15 interrupts in PIC16F877, but i guess those are counted including timer overflow interrupts etc... which are useless in this case.

This is what datasheet say about INTCON register.

Can I have 4 independent interrupts using bit0, RBIF? It represent change in PB7:PB4. How can I identify which pin changed, is it by reading the port value in the interrupt routine?

Even I get positive answers to above, I need 8 interrupts? of course I can still use INTE, for PORTB0 change. Then 4 + 1 = 5, but what about other 3? (However being all the 8 interrupt events are of same type, the 4 + 1 + 3 = 8 thing seems ugly, isn't it?)

There's no other heavy tasks expected from the micro-controller other that monitoring 8 pins. (Talking about the other tasks, it'll have to maintain a set of separate counter variables and frequently transmit about 4 bytes to PC serially)

Any suggestions are welcome. Even if it's about changing the micro-controller for more suited one (but uh.. don't tell me to go away from PICs).

Answer 1

This is C pseudo-code to explain one idea. It uses and exclusive OR to work out which pins have changed and will call your different handlers within the one RBIE interrupt. Depending on how critical the application is you may want to check how the PIC handles situations such as a port changing while the interrupt is executing to make sure you won't miss any events.

int old_port_b;

void isr_handler()
{
    int new_port_b, changed_pins;
    new_port_b = read_port_b();
    changed_pins = new_port_b ^ old_port_b;
    if (changed_pins | 1)
        rb0_hander();
    if (changed_pins | 2)
        rb1_hander();
        // ... etc
    old_port_b = new_port_b;
}

int main()
{
    old_port_b = read_port_b();
    enable_interrupt();
}

Answer 2

That part only has 4 pin-change interrupts and a few others you can set up on selected edges. One strategy would be to detect a change in the 8 bit value externally, then interrupt on the mismatch. That gets messy in hardware, but will so exactly what you want.

The important parameters that you haven't stated are how fast you need to respond to a pin change, and what minimum time will a pin change persist for it to be valid. Depending on the answers, you could poll based on a regular interrupt in firmware. The 16F877 can run at 5 MHz instruction rate, and checking for a change would only take a few instruction. Let's say you set up the interrupt every 50 instructions. That would leave a good portion of the processor time to the foreground code. The interrupt rate would be 100 kHz and the period 10 µs. Of course the foreground code then still needs to see the change flag and do something about it, so the response time will be more than 10 µs, but you haven't said anything about what you need to do when a change is detected. If this just needs to respond in human time, then you can run the interrupt a lot slower.

Answer 3

You may use 8-input gate NAND as mentioned by @Brian Drummond to rise an interrupt over INT pin and also connect your interrupt sources to 8-Bit Parallel-In/Serial-Out Shift Register like "74HC165N", so then you will need to just read the data from that Shift Register after interrupt rised and that will give you the information about your actual interrupt source ... it is may be not the fastest way, but easy to expand and will use not more then 5 pins, and if you add address controlling system (MUX, LATCH ,...), then you will need only one pine for interrupt notification and other pins may be reused at different time for different resources ;)