PORTB and INT external interrupts stucks the code

Question

I am working on a project with PIC16F877 (using MPLABX). I use RB0 pin external interrupt and RB4 pin portb interrupt to detect zero cross detection. I did everything correct, in proteus simulation everything was okey. Then I set up the circuit on breadboard, the LCD wasnt displaying the numbers (just the white dots). I thought the problem is the RB0 and PORTB interrupt. I wrote a simple code just includeshe PORTB interrupt and LCD and simulated. Everything is okey until the interrupt occures, when interrupt comes the code stops. I am new to PIC, this is the code I wrote:

/*
 * File:   lcd_deneme_16f877a.c
 * Author: BATUHAN
 *
 * Created on 28 Aral?k 2022 Çar?amba, 13:52
 */


#include <xc.h>
#include <stdio.h>
#include <stdint.h>
#pragma config FOSC = XT        // Oscillator Selection bits (HS oscillator)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = ON       // Power-up Timer Enable bit (PWRT enabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bit (BOR disabled)
#pragma config LVP = OFF        // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
#pragma config CPD = ON         // Data EEPROM Memory Code Protection bit (Data EEPROM code-protected)
#pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = ON          // Flash Program Memory Code Protection bit (All program memory code-protected)
#define _XTAL_FREQ 4000000


void __interrupt() interrpt()
{
    if(INTF)
    {
        uint8_t dummy = PORTB; // Read PORTB to end mismatch condition
        INTF=0;
        RD0=RD0^1;
    }
    
    if(RBIF==1 && RB4==1)
    {
        uint8_t dummy = PORTB; // Read PORTB to end mismatch condition
        RBIF=0;
        RD0=RD0^1;
    }
    

}

void main(void) 
{
    
    TRISD=0X00;
    PORTD=0X00;
    TRISB=0b00010001;
    PORTB=0X00;
    
    INTCON=0b11011000;   // GIE PEIE TMR0IE INTE RBIE TMR0IF INTF RBIF
    OPTION_REGbits.nRBPU = 1;
    INTEDG=1;  
    
    int V=0;
    
    while(1)
    {
        
        V++;
        __delay_ms(200);
        
       
    }
    
    
    return;
}

I tried the PORTB and RB0 interrupts separately and the problem still occurs. What could be the problem. Thanks in advance

Answer 1

This is because your program stucks in interrupt routine due to the lack of proper handling of interrupts. You don't seem to handle the INT interrupt at all. For RB interrupt-on-change (IOC), you have to handle it sort of a little different and end the mismatch condition before clearing the flag. According to the PIC16F877A Datasheet this how the IOC works and must be handled:

Four of the PORTB pins, RB7:RB4, have an interrupt-on-change feature. Only pins configured as inputs can cause this interrupt to occur (i.e., any RB7:RB4 pin configured as an output is excluded from the interrupt-on-change comparison). The input pins (of RB7:RB4)are compared with the old value latched on the last read of PORTB. The “mismatch” outputs of RB7:RB4 are OR’ed together to generate the RB port change interrupt with flag bit RBIF (INTCON<0>). This interrupt can wake the device from Sleep. The user, in the Interrupt Service Routine, can clear the interrupt in the following manner:
a) Any read or write of PORTB. This will end the mismatch condition.
b) Clear flag bit RBIF.
A mismatch condition will continue to set flag bit RBIF. Reading PORTB will end the mismatch condition and allow flag bit RBIF to be cleared.

So your interrupt service code should look like the following:

void __interrupt() interrpt()
{
    if(RBIF && RB4)
    {
        volatile uint8_t dummy = PORTB; // Read PORTB to end mismatch condition
        RBIF=0;
        RD1=RD1^1;
    }
    else if(INTIF) {
        INTIF = 0;
        RD0 = !RD0; // Toggle D0 for INT interrupt
    }
}

A friendly reminder
The proteus simulation is ok for some cases. However the simulation runs in ideal conditions. That's why you may not get the same expected behaviour in the real world conditions compared to proteus' ideal simulation conditions.

Answer 2

void __interrupt() interrpt()
{
    if(RBIF)
    {
        PORTB; // Read PORTB to end the mismatch condition
        RBIF=0;
        if(RB4)
            RD1=RD1^1;
        
    }
    else if(INTF) {
        INTF = 0;
        RD0 = !RD0; // Toggle D0 for INT interrupt
        
    }
}