title: PIC16F1829 UART RX Interrupt not working using MPLABX and XC8 compiler
body: <p>I am new to writing firmware for 8-bit PICs and could use some help with my code. I am using a PIC16F1829 for an LED module which gets RX commands. I am just trying to get the basics setup like turn on LEDs when a certain value is received on RX pin, but can't even get that.</p>
  
  <p>Would like to get UART working via interrupts but can't even get it working with polling in main loop. My interrupt vector is commented out in the code below. </p>
  
  <p>RX pin: RC5</p>
  
  <p>TX pin: RB7</p>
  
  <p>Pin to toggle LEDs on and off: RA5</p>
  
  <p>Pin RA5 works fine to toggle LEDs on and off. TX pin is working, though I have not confirmed if interrupt TXIF is also not working like RCIF is not working.</p>
  
  <p>I have tried reading RCIF and PIR1bits.RCIF. Both of them compiled. Neither one worked. I have tried this on two different PICs on 2 different LED modules. They turn on, but reading RX pin didn't work on either. </p>
  
  <p>Variable RXIN is initially defined as 3 and thus due to the RXIN-- loop within the main loop the lights flash 3 times at startup so I know it is entering the main loop. But as far as I can tell the RCIF interrupt is not firing upon reception at RX pin.</p>
  
  <p>I have confirmed on oscilloscope that the signal into RX and out of TX pins using same baud, so I think baud rate is configured correctly (300 baud, 8N1.) I have also confirmed on oscilloscope RX pin receiving strong and clean 5V signal. Neither polling RCIF or using an interrupt service routing has worked thus far. If anyone can see the issues with my code that I am not seeing, your help would be greatly appreciated. </p>
  
  <p>My code:</p>
  
  <pre><code>#include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;xc.h&gt;
  
  // This is for 300 baud rate
  #define _BAUD_PRESCALER_LOW_ 0x2A
  #define _BAUD_PRESCALER_HIGH_ 0x68
  #define _XTAL_FREQ 32000000
  
  #pragma config FOSC = INTOSC    // Oscillator Selection-&gt;INTOSC oscillator: I/O function on CLKIN pin
  #pragma config WDTE = OFF    // Watchdog Timer Enable-&gt;WDT enabled
  #pragma config PWRTE = OFF    // Power-up Timer Enable-&gt;PWRT disabled
  #pragma config MCLRE = OFF    // MCLR Pin Function Select-&gt;MCLR/VPP pin function is digital input
  #pragma config CP = OFF    // Flash Program Memory Code Protection-&gt;Program memory code protection is disabled
  #pragma config CPD = OFF    // Data Memory Code Protection-&gt;Data memory code protection is disabled
  #pragma config BOREN = ON    // Brown-out Reset Enable-&gt;Brown-out Reset enabled
  #pragma config CLKOUTEN = OFF    // Clock Out Enable-&gt;CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin
  #pragma config IESO = OFF    // Internal/External Switchover-&gt;Internal/External Switchover mode is disabled
  #pragma config FCMEN = OFF    // Fail-Safe Clock Monitor Enable-&gt;Fail-Safe Clock Monitor is disabled
  
  // CONFIG2
  #pragma config WRT = OFF    // Flash Memory Self-Write Protection-&gt;Write protection off
  #pragma config PLLEN = ON    // PLL Enable-&gt;4x PLL enabled
  #pragma config STVREN = ON    // Stack Overflow/Underflow Reset Enable-&gt;Stack Overflow or Underflow will cause a Reset
  #pragma config BORV = LO    // Brown-out Reset Voltage Selection-&gt;Brown-out Reset Voltage (Vbor), low trip point selected.
  #pragma config LVP = OFF
  
  int flagRXFramingError = 0;
  int flagRXOverrunError = 0;
  volatile unsigned char RXIN = 3;
  
  unsigned char UARTRead(){
      return RCREG;
  }
  
  void writeRXIN(unsigned char a){
      RXIN = a;
  }
  
  void TX(unsigned char a){
      while(!TXIF){}
      TXREG = a;
  }
  
  int main(int argc, char** argv) {
  
      // SCS FOSC; SPLLEN disabled; IRCF 8MHz_HF; 
      OSCCON = 0xF0;
      // TUN 0; 
      OSCTUNE = 0x00;
      // Set the secondary oscillator
      // Wait for PLL to stabilize
      while(PLLR == 0)
      {
      }
  
      // WDTPS 1:65536; SWDTEN OFF; 
      WDTCON = 0x16;
      __delay_ms(5);
  
      GIE = 1; // Global interrupts enabled
      __delay_ms(5);
      PEIE = 1; // Active peripheral interrupts enabled
      __delay_ms(5);
      RCIE = 1; // Enable USART Receive interrupt
      __delay_ms(5);
      TXIE = 1; // Enable USART Transmitter interrupt
      __delay_ms(5);
      ADIE = 1; // Enable ADC interrupts
      __delay_ms(5);
      RXDTSEL = 0; // RX is on RC5 pin
      __delay_ms(5);
      TXCKSEL = 0; // TX is on RB7 pin
      __delay_ms(5);
  
      TRISC5 = 1; // RX pin set as input
      __delay_ms(5);
  
      SPEN = 1; // Serial Port Enabled
      __delay_ms(5);
      SYNC = 0; // Asynchronous mode
      __delay_ms(5);
      RX9 = 0; // 8 bit reception
      __delay_ms(5);
      TX9 = 0; // 8-bit transmission
      __delay_ms(5);
      CREN = 1; // Receiver enabled
      __delay_ms(5);
      TXEN = 1; // Transmitter enabled 
     __delay_ms(5);
      BRG16 = 1; // 16-bit baud generation
      __delay_ms(5);
      BRGH = 1; // High baud rate enabled
      __delay_ms(5);
      ABDEN = 0; // Auto baud detect disabled
      __delay_ms(5);
  
      // Baud prescaler n = [Fosc/(D*BR)] - 1
  
      SPBRGH = _BAUD_PRESCALER_HIGH_;
      __delay_ms(5);
      SPBRGL = _BAUD_PRESCALER_LOW_;
      __delay_ms(5);
  
      TRISC6 = 0; // IadjPWM pin configured as output
      __delay_ms(5);
      ANSC6 = 0; // IadjPWM pin not analog input
      __delay_ms(5);
      TRISA5 = 0; // DimPWM pin configured as output
      __delay_ms(5);
  
      LATC6 = 1; // Max current for now until PWM written
      __delay_ms(5);
  
      while(1){
  
      // Inline assembly code to clear watchdog timer
      //asm("CLRWDT");
  
      /*if(RXIN == 5){
          RA5 = 1;
      }
      else{
          RA5 = 0;
      }*/
  
          if(PIR1bits.RCIF){
              writeRXIN(UARTRead());
              //RA5 = 0;
              TX(RXIN);
          } // end if RCIF
  
          while(RXIN &gt; 0){
              RA5 = 1;
              __delay_ms(100);
              RA5 = 0;
              __delay_ms(100);
              RXIN--;
          }
  
      } 
      // infinite loop
      // never leave this loop
  
      RA5 = 1;
      return (EXIT_SUCCESS);
  } // end main
  
  /*void interrupt ISR(void){
      if(RCIF){// if USART Receive interrupt flag
          RA5 = 1;
  
          if(FERR){
              flagRXFramingError = 1;
              SPEN = 0;
              SPEN = 1;
  
          }
          if(OERR){
              flagRXOverrunError = 1;
              CREN = 0;
              CREN = 1;
          }
  
          while(RCIF){ // RCIF high as long as there is data in FIFO register. Read RCREG to clear RCIF flag
              writeRXIN(UARTRead());
          }
  
          RA5 = 0;
      }
  
      if (TXIF){// if USART Transmit interrupt
          TXIF = 0; // Clear interrupt flag
      }
  } // end ISRs*/
  </code></pre>